JP2009009253A - Program execution method, program, and program execution system - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a technology for increasing program speed by optimization of a "JIT application criterion" based on an "accelerator adequacy point" and a technology for reducing memory consumption by reducing codes to be compiled by the optimization. <P>SOLUTION: In the virtual machine 2 of a program execution system, a task for program compilation and analysis inputs an intermediate code, and detects a static "accelerator adequacy point" for each program section, and outputs "JIT application criterion information", and a task for program execution inputs an intermediate code or a native code, and executes a program, and decides whether to apply the "accelerator" and the "JIT" from the "JIT application criterion information" of each program section, and executes the program by the "interpreter having the accelerator" or the "JIT". <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention relates to a program execution technique, and more particularly to a technique effective when applied to a virtual machine having an “accelerator” and a “JIT”.

  For example, in the case of Java (registered trademark) as a program execution method for executing intermediate code at high speed, the number of method executions is counted at the time of execution, and the program is compiled when the threshold value is exceeded. There is a method called “JIT” that speeds up the process. Further, as a program execution method for executing intermediate code at high speed, there is a method called “accelerator” that speeds up the translation and execution of the intermediate code by hardware.

  Further, in the method described in Patent Document 1, only one compiled part of the “JIT” compiler is compiled and used by using the idle time in advance. As a result, native code can be used without compiling time, and the speed can be increased by compiling time.

  In the method described in Patent Document 2, an execution task and a compile task are provided, the former is preferentially processed, and the first execution of the portion to be compiled uses an interpreter process, and the second and subsequent uses a compile result. To process. As a result, the speed is increased by “compile time + native code execution time−interpreter processing time”.

  Further, in the method described in Patent Document 3, a portion where the number of times of execution in a program is large is estimated by static analysis, and prioritization is performed based on the estimated portion. This speeds up compilation time if native code is prepared at runtime.

In the method described in Patent Document 4, interpreter non-acceleration instructions can be cached in virtual machine execution to speed up interpreter execution.
Japanese Patent Laid-Open No. 11-237989 JP 2004-355277 A JP 2004-326760 A Japanese Patent Laid-Open No. 2004-280766

  By the way, in a virtual machine having “accelerator” and “JIT”, both of them are not good at speeding up. Which technology should be applied for each program part is not clearly specified. How to determine the best choice is one of the current important challenges. The method described in Patent Document 4 described above increases the speed of a virtual machine having an “accelerator”, but there is no description regarding cooperation with “JIT”.

  Accordingly, the present invention has been made in order to solve the problems in view of the above circumstances, and an object of the invention is to optimize the “JIT application determination criteria” based on the “accelerator suitability degree point”, and to program It is to provide a technology for speeding up the process. It is another object of the present invention to provide a technique for reducing the memory usage by suppressing the compilation target range by the above optimization.

  The above and other objects and novel features of the present invention will be apparent from the description of this specification and the accompanying drawings.

  Of the inventions disclosed in the present application, the outline of typical ones will be briefly described as follows.

  In order to achieve the above object, the present invention is a task in charge of program compilation and analysis, which inputs intermediate code and detects static “accelerator suitability degree points” for each program part to determine “JIT application determination” "Reference information" is output. Next, in the task in charge of program execution, input intermediate code or native code to execute the program, and determine whether to apply “Accelerator” and “JIT” from “JIT application criteria information” for each program part. The program is executed by “interpreter having accelerator” or “JIT”. The present invention is applied to such a program execution method, program, and program execution system.

  Among the inventions disclosed in the present application, effects obtained by typical ones will be briefly described as follows.

  According to the present invention, from the “JIT application determination criterion information” based on the “accelerator suitability degree point” for each program part extracted by static analysis, the optimum application determination of “accelerator” and “JIT” is performed. The program is executed optimally by “interpreter having accelerator” or “JIT”, so that the program can be speeded up.

  Further, according to the present invention, by optimizing the “JIT application determination criterion” based on the “accelerator suitability degree point”, it is possible to suppress the compilation target range and reduce the memory usage.

  Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings. Note that the present invention is not limited thereby. In all the drawings for explaining the embodiments, the same members are denoted by the same reference symbols in principle, and the repeated explanation thereof is omitted.

<Outline of Embodiment of the Present Invention>
In the embodiment of the present invention, a program execution system characterized by realizing each means of program execution by a computer and a program execution method characterized by executing each step of program execution by a computer will be described. However, the present invention is not limited to this, and can also be applied to a program characterized by causing a computer to execute each step of program execution.

<Program execution system>
FIG. 1 is a diagram showing an outline of a program execution system according to the present embodiment. The program execution system according to the present embodiment is executed on a computer, and program execution is initially executed by an interpreter including an accelerator, and the program execution is switched to execution by a compiler in the middle according to a threshold value of the number of times of repeated execution. In this method, the performance difference between the case where the program is executed by the accelerator and the case where the program is executed by the compiler is estimated, and the timing for switching to the implementation by the compiler is optimized to speed up the program execution.

  In FIG. 1, a virtual machine 2 executes an intermediate code 1 obtained by converting a source program described in a high-level language as an input. The virtual machine 2 includes a task allocation unit 3 that allocates a task in charge of executing the intermediate code 1 and a task in charge of compilation and analysis to an arbitrary core (CPU) in a multi-core environment, and an execution control that controls the execution of the intermediate code 1 Part 4, a compile / analysis control part 7 for controlling the compilation and analysis of the intermediate code 1, and an accelerator (ACC) / according to “weight of accelerator-incompatible instruction” and “compiler application threshold for each method” It is composed of compiler (JIT) determination information 21 and native code 22 which is a compilation result of intermediate code 1.

  The execution control unit 4 includes an accelerator (ACC) / compiler (JIT) determination unit 5 and an execution unit 6 that receive the accelerator / compiler determination information 21 and determine whether to apply the accelerator / compiler. Is done. The compile / analysis control unit 7 includes a static analysis unit 8 that outputs accelerator / compiler determination information 21 and a compile unit 9. Furthermore, the execution unit 6 includes a dynamic analysis unit 61 that updates the accelerator / compiler determination information 21 by dynamic analysis, an interpreter (INT) unit 62 that executes an interpreter, and a compiler (JIT) that outputs native code 22. The unit 63 is configured.

  In particular, in this virtual machine 2, the compile / analysis control unit 7 inputs the intermediate code 1 converted from the source program, determines the “accelerator suitability degree point” for each program part, and this “accelerator It functions as each means for determining “JIT application determination criterion information” based on “aptitude degree point”. Further, the execution control unit 4 performs application determination of “interpreter having accelerator” and “JIT” based on “JIT application determination criterion information”, and “interpreter having accelerator” based on the result of the application determination. It functions as each means for executing the program by separating the execution by “JIT” and the execution by “JIT”.

  Specifically, when the compile / analysis control unit 7 determines the “accelerator suitability degree point” for each program part, it detects dynamic information of the “number of loop iterations” and based on this dynamic information Furthermore, it functions as each means for determining an “accelerator suitability degree point” for each correct program part. Alternatively, when determining the “accelerator suitability degree point” for each program part, the benchmark program is executed in advance, the average execution time of the “accelerator non-corresponding instruction” is detected, and each “accelerator The average execution time of “non-corresponding instructions” is pointed to “accelerator non-corresponding instruction weights”, and the total of “accelerator non-corresponding instruction weights” included in each program part is the “accelerator non-corresponding instruction weight”. It functions as each means to be determined as “relaxer aptitude degree point”.

<Program execution method>
A program execution method in the program execution system according to the present embodiment will be described with reference to FIGS. In this program execution method, the compile / analysis control unit 7 of the virtual machine 2 inputs the intermediate code converted from the source program, determines the “accelerator suitability degree point” for each program part, and this “accelerator” Each step of determining “JIT application determination criterion information” based on “the suitability degree point of the generator” is executed. Further, the execution control unit 4 determines whether to apply “interpreter having accelerator” and “JIT” based on “JIT application determination criterion information”, and “interpreter having accelerator” based on the result of the application determination. Each step of executing the program is executed by separating the execution by “JIT” and the execution by “JIT”. Below, it demonstrates concretely based on each figure.

  FIG. 2 is an operation flowchart of the task assignment unit 3 in FIG. With reference to FIG. 2, a flow of task assignment processing performed after the virtual machine 2 is started will be described. First, the core number is determined in process step 31. If “1” (Y), the process proceeds to process step 33, the execution process of the intermediate code 1 is performed, and then the task allocation process is terminated. If the core number is other than “1” in process step 31 (N), the process proceeds to process step 32. Next, the core number is determined in process step 32. If it is “2” (Y), the process proceeds to process step 34, where the intermediate code 1 is compiled and analyzed, and then this task allocation process is terminated. If the core number is other than “2” in process step 32 (N), the task assignment process is terminated.

  FIG. 3 is an operation flowchart of the static analysis unit 8 in FIG. The flow of the static analysis process for the intermediate code 1 will be described with reference to FIG. First, an intermediate code 1 is input in processing step 801. Description will be made assuming that an intermediate code converted from a source program described in the Java (registered trademark) language shown in FIG. 5 is input. In Java (registered trademark), a code corresponding to an intermediate code is called a byte code. A method for converting a Java (registered trademark) source program into bytecode is a well-known technique disclosed by Sun Microsystems, Inc., and therefore will not be described in this specification.

  Next, in the processing step 802, the “accelerator non-corresponding instruction weight table” is input. An example will be described with reference to FIG. The accelerator non-corresponding instruction weight is set to a value obtained by executing an appropriate benchmark program in advance, measuring the execution time for each instruction, and taking the average as a point. The “accelerator-incompatible instruction weight table” includes “accelerator-incompatible instruction name” 2101 and “weight” 2102. In this example, “opcode1” is weighted as “100” 2103 and “opcode2” as weight. It is assumed that “10” 2104 and “10” 2105 are set as the weights of “opcode3”.

  Next, in process step 803, a method is detected, and “method1” shown in the 104th line in FIG. 5 is detected. Next, in process step 804, a value “0” is set as the method weight. Next, a loop is detected in process step 805, and the loop shown in the 106th line in FIG. 5 is detected. Next, in process step 806, the loop repetition count “100” is detected. Next, in processing step 807, a value “0” is set to the loop weight. Next, in step 808, an instruction is detected, and “opcode1” on line 107 in FIG. 5 is detected.

  Next, it is determined in processing step 809 whether or not the instruction is an accelerator non-corresponding instruction, and “opcode1” is an accelerator non-corresponding instruction registered in the “accelerator non-corresponding instruction weight table”. (Y) Proceed to processing step 810. If it is determined in process step 809 that the instruction is not an accelerator non-corresponding instruction (N), the process proceeds to process step 812.

  Next, in a processing step 810, “100” is detected as the “accelerator-incompatible instruction weight” of the instruction “opcode1”. Next, in processing step 811, the sum “100” of the loop weight “0” and the command weight “100” is set as the loop weight. Next, it is determined in processing step 812 whether or not another instruction exists in the loop. Since the instruction “opcode2” shown in the 108th line in FIG. 5 exists (Y), the processing returns to processing step 809. The above processing is repeated to set “110” as the loop weight. Next, since there is no other instruction in the loop at process step 812 (N), the process proceeds to process step 813.

  Next, in processing step 813, it is determined whether or not the number of loop iterations is a constant. Since it is a constant “100” (Y), the processing proceeds to processing step 814. In process step 814, the product “11000” of the current loop weight “110” and the loop iteration count “100” is set as the current loop weight, and the process proceeds to process step 816. If it is determined in process step 813 that the number of loop iterations is a variable (N), the process proceeds to process step 815 to set the product of the loop weight and the provisional value “10” as the loop weight. Proceed to When dynamic analysis is performed by the dynamic analysis unit 61 and the loop repetition count is determined, the provisional value “10” is replaced with the determined value, and the loop weight is recalculated.

  Next, in process step 816, the sum of the method weight “0” and the loop weight “11000” “11000” is set as the method weight. Next, it is determined in process step 817 whether or not there is another loop. Since there is no loop (N), the process proceeds to process step 818. If it exists in process step 817 (Y), the process returns to process step 806 and the above process is repeated.

  Next, a “JIT application threshold table” is generated in process step 818. An example is shown in FIG. The “JIT application threshold value table” includes “method name” 2111, “weight” 2112, and “JIT application threshold value” 2113. In step 818, the record 2114 is registered. A character string “method1” is set in “method name” 2111, a value “11000” is set in “weight” 2112, and a value “10” is set in “JIT application threshold” 2113. The “JIT application threshold” 2113 is set to “10” when the “weight” 2112 is “10000” or more, and is set to “10” when the “weight” 2112 is less than “10000” and “5000” or more. When “20” is set and “weight” 2112 is less than “5000”, “30” is set.

  Next, it is determined whether or not another method exists in processing step 819. Since “method2” shown in the 110th line in FIG. 5 exists (Y), the processing returns to processing step 804 and the above processing is repeated. Thereby, the records indicated by 2115 and 2116 in FIG. 7 are registered. If there is no other method in process step 819, the static analysis process is terminated.

  FIG. 4 is an operation flowchart of the execution control unit 4 in FIG. The flow of execution control processing will be described with reference to FIG. First, the intermediate code 1 is input at processing step 41. The source code image of the intermediate code 1 is as shown in FIG. Next, a method is detected in the processing step 42, and “method1” shown in the 104th line in FIG. 5 is detected. Next, a “JIT application threshold table” shown in FIG.

  Next, in processing step 44, it is determined whether or not the information of the method “method1” is registered in the “JIT application threshold value table”. Since it is already registered (Y), the processing proceeds to processing step 48. In process step 48, the JIT application threshold “10” 2114 of this method “method1” is detected. If the information of this method is not registered in process step 44 (N), the process proceeds to process step 45. In process step 45, an “accelerator non-corresponding instruction weight table” is input. Next, in processing step 46, the weight of this method is calculated. Next, in process step 47, a JIT application threshold value is set, and the process proceeds to process step 48.

  Next, in process step 49, it is determined whether or not the number of executions of the method “method1” is equal to or greater than the JIT application threshold value. If it exceeds the threshold value (Y), the process proceeds to process step 410; Go to 411. In processing step 410, JIT execution is performed, and in processing step 411, execution is performed by an interpreter including an accelerator. After both processing steps 410 and 411 are processed, the process proceeds to processing step 412.

  Next, in a processing step 412, dynamic processing is performed. In dynamic processing, the number of loop iterations is obtained, and the “accelerator non-corresponding instruction weight table” is updated. Next, it is determined in process step 413 whether or not there is another method. Since “method2” shown in the 110th line in FIG. 5 exists (Y), the process returns to process step 42 and the above process is repeated. If it does not exist in process step 413 (N), this execution control process is terminated.

  For example, when the JIT application threshold is fixed at “20” by the program execution method by the task allocation process, the static analysis process, and the execution control process described above, the time until the compilation of each method is 11000 × 20 + 1200 × 20 + 5000 × For 20 = 344000, 11000 × 10 + 1200 × 30 + 5000 × 20 = 246000, which is 40% faster.

<Program execution processing device>
FIG. 8 is a diagram showing an outline of a program execution processing device having a hardware configuration for realizing the program execution system in FIG. In FIG. 8, the program execution processing device includes a CPU 1 (1001) and a CPU 2 (1002) for program execution, a main storage device 1003, a secondary storage device 1004, and a combining device 1005 for combining them. The secondary storage device 1004 stores the intermediate code 1 described above. Further, the virtual machine 2 described above is constructed in the main storage device 1003.

  As described above, according to the program execution system and the program execution method of the present embodiment, the intermediate code is input to detect the static “accelerator suitability degree point” for each program part, and the “JIT “Applicability criteria information” is output, then intermediate code or native code is input and the program is executed. From “JIT applicability criteria information” for each program part, “accelerator” and “JIT” applicability are determined. If the program is executed by “interpreter having accelerator” or “JIT”, the program can be speeded up.

  Further, by optimizing the “JIT application determination criteria” based on the “accelerator suitability degree point”, it becomes possible to suppress the compilation target range and reduce the memory usage.

  In particular, when deciding whether to apply both functions of a virtual machine equipped with an “interpreter including accelerator” and “JIT”, the program can be optimized for each part of the program to be executed, and the program execution speed can be increased. It is possible to reduce the memory usage by suppressing the above.

  As mentioned above, the invention made by the present inventor has been specifically described based on the embodiment. However, the present invention is not limited to the embodiment, and various modifications can be made without departing from the scope of the invention. Needless to say.

  For example, in the above-described embodiment, the program execution system and the program execution method have been described. However, the present invention is not limited to this, and the present invention is also applicable to a program characterized by causing a computer to execute each step of program execution. is there. In this case, the execution control unit and the compile / analysis control unit of the virtual machine described above are realized by a program, and the same processing can be performed by executing this program.

  The program execution method, program, and program execution system of the present invention can be used for a virtual machine having an “accelerator” and a “JIT”.

It is a figure which shows the outline | summary of the program execution system of embodiment of this invention. It is a figure which shows the flow of a task allocation process in the program execution system of embodiment of this invention. It is a figure which shows the flow of a static analysis process in the program execution system of embodiment of this invention. It is a figure which shows the flow of an execution control process in the program execution system of embodiment of this invention. It is a figure which shows the example of an input source program in the program execution system of embodiment of this invention. It is a figure which shows the accelerator non-object instruction weight table in the program execution system of embodiment of this invention. It is a figure which shows the JIT application threshold value table in the program execution system of embodiment of this invention. It is a figure which shows the outline | summary of the program execution processing apparatus which implement | achieves the program execution system of embodiment of this invention.

Explanation of symbols

DESCRIPTION OF SYMBOLS 1 ... Intermediate code, 2 ... Virtual machine, 3 ... Task allocation part, 4 ... Execution control part, 5 ... Accelerator / compiler determination part, 6 ... Execution part, 7 ... Compile / analysis control part, 8 ... Static analysis 9 compile unit 21 Accelerator / compiler determination information 22 Native code 61 Dynamic analysis unit 62 Interpreter unit 63 Compiler unit
1001 ... CPU1, 1002 ... CPU2, 1003 ... Main storage device, 1004 ... Secondary storage device, 1005 ... Coupling device.

Claims (10)

Depending on the calculator
Inputting intermediate code converted from the source program and determining "accelerator suitability degree point" for each program part;
Determining “JIT application criteria information” based on the “accelerator suitability degree point”;
Determining whether to apply “interpreter having accelerator” and “JIT” based on the “JIT application determination criterion information”;
Executing the program by separating the execution by the “interpreter having an accelerator” from the execution by the “JIT” based on the result of the application determination;
The program execution method characterized by performing. The program execution method according to claim 1,
In the step of determining the “accelerator suitability degree point” for each program part, the step of detecting the dynamic information of the “number of loop iterations” and the more accurate “ A step of determining an “accelerator suitability degree point”. The program execution method according to claim 1,
In the step of determining the “accelerator suitability degree point” for each program part, a benchmark program is executed in advance, an average value of execution times of “accelerator non-corresponding instructions” is detected, and each “accelerator The average value of the execution time of the “non-accelerator instruction” is pointed to “accelerator non-instruction weight” and the total of “accelerator non-instruction weight” included in each program part Determining the “accelerator suitability degree point” of the part, and executing the program. The program execution method according to claim 1,
The “accelerator” performs the translation and execution of the intermediate code by hardware, and the “JIT” executes the portion of the intermediate code that is repeatedly executed, and the number of executions exceeds the threshold at the time of execution. A program execution method characterized in that the program is compiled at a point in time and the native code is subsequently executed. In the calculator,
Inputting intermediate code converted from the source program and determining "accelerator suitability degree point" for each program part;
Determining “JIT application criteria information” based on the “accelerator suitability degree point”;
Determining whether to apply “interpreter having accelerator” and “JIT” based on the “JIT application determination criterion information”;
Executing the program by separating the execution by the “interpreter having an accelerator” from the execution by the “JIT” based on the result of the application determination;
A program characterized by having executed. The program according to claim 5,
In the step of determining the “accelerator suitability degree point” for each program part, the step of detecting the dynamic information of the “number of loop iterations” and the more accurate “ And a step of determining an “accelerator suitability degree point”. The program according to claim 5,
In the step of determining the “accelerator suitability degree point” for each program part, a benchmark program is executed in advance, an average value of execution times of “accelerator non-corresponding instructions” is detected, and each “accelerator The average value of the execution time of the “non-accelerator instruction” is pointed to “accelerator non-instruction weight” and the total of “accelerator non-instruction weight” included in each program part And determining the “accelerator suitability degree point” of the part. Depending on the calculator
Means for inputting intermediate code converted from the source program and determining "accelerator suitability degree point" for each program part;
Means for determining “JIT application criteria information” based on the “accelerator suitability degree point”;
Means for determining application of “interpreter having accelerator” and “JIT” based on the “JIT application determination criterion information”;
Means for executing a program by separating execution by the “interpreter having an accelerator” from execution based on the result of the application determination and execution by the “JIT”;
A program execution system characterized by realizing the above. The program execution system according to claim 8, wherein
The means for determining the “accelerator suitability degree point” for each program part includes means for detecting dynamic information of the “number of loop iterations”, and more accurate “for each program part based on the dynamic information. Means for determining an “accelerator suitability degree point”, and a program execution system. The program execution system according to claim 8, wherein
In the means for determining the “accelerator suitability degree point” for each program part, a benchmark program is executed in advance and an average value of execution times of “accelerator non-corresponding instructions” is detected. The average value of the execution time of the “non-accelerator instruction” is pointed to “accelerator-incompatible instruction weight” and the total of the “accelerator non-instruction weight” included in each program part And a means for determining the “accelerator suitability degree point” of the part.

Images