JP2011002976A - Program execution controller - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a program execution controller reducing overhead when a method during JIT (Just In Time) compilation is called.SOLUTION: This program execution controller decides whether the method is already compiled in time of the method call, and executes a native code of the method when the method is already compiled. The program execution controller selects one of the execution of the native code of the method after waiting completion of the compilation of the method and processing of an intermediate code of the method by an interpreter when the method is not already compiled. At that time, the program execution controller selects the one expected that an execution time is shorter at that time point.

Description

  The present invention relates to a program execution control apparatus that executes a program including an intermediate code string, and more particularly to a program execution control apparatus using a JIT compiler.

  One of the typical virtual machines that execute programs without depending on a specific platform is a technology using Java (registered trademark) language. For example, there is a JVM (Java (registered trademark) Virtual Machine) that interprets and executes a Java (registered trademark) bytecode.

  Java (registered trademark) bytecode is a kind of intermediate code generated by compiling source code written in Java (registered trademark) language. The JVM functions as a so-called interpreter that sequentially interprets the bytecode and causes the processor to execute processing.

  Through the intervention of the JVM, a platform-independent program execution environment can be realized, but the execution speed is generally slower than the execution speed of a program converted into native code that can be directly understood by the processor. Therefore, a JVM having a JIT (Just In Time) compiler for compiling bytecode into native code at the time of program execution has been devised and used in general.

  A program written in a script language such as Java (registered trademark) Script is executed by a script engine. This script engine is useful as a means for realizing a platform-independent program execution environment. For this reason, the script engine is implemented in a browser or the like as a means for realizing an application on an interactive network.

  A program written in such a script language is once converted into an intermediate code by a script engine and then sequentially executed by an interpreter process. Also in such a script engine, the thing provided with the JIT compiler is known like the above-mentioned JVM.

  The conventional program execution control apparatus equipped with both the interpreter and the JIT compiler as described above determines whether or not to JIT compile the method by analyzing the structure of the program itself or counting the number of times the method is activated during the interpreter process. To decide. This is because there is a high possibility that it will be frequently called in the future, and JIT compilation is preferentially performed at a place worth JIT compilation. However, even if JIT compilation is performed with priorities assigned in this way, JIT compilation is concentrated in a certain period of time such as the beginning of program execution, so that there is a problem that the response performance of the program is significantly reduced. It was.

  In order to solve this problem, in the conventional technology, JIT compilation is performed in parallel as a low-priority task different from a program execution task such as interpreter processing or native code execution (for example, See Patent Decentralization 1).

  In the conventional technique disclosed in Patent Document 1, when a method that has not been JIT compiled is called, the method is always executed by an interpreter process. Also, when a method that is undergoing JIT compilation is called, the native code is executed after the end of JIT compilation.

JP 2004-355277 A

  However, the conventional technique has a problem that when a method being JIT compiled is called, the process cannot be switched appropriately based on the JIT compilation status of the method.

  In other words, since native code is executed after the end of JIT compilation, when a method is called, the method may still be immediately after the start of JIT compilation. In this case, the time waiting for the end of JIT compilation is an overhead. On the other hand, in the case of an implementation that always performs interpreter processing, when a method is called, if the JIT compilation of the method has already reached just before termination, the time required for execution of the intermediate code interpreter processing remains overhead. It becomes.

  The present invention solves the above-described conventional problems, and provides a program execution control device that selects native code execution or interpreter processing when a method is called based on the JIT compilation status of the method. With the goal.

  In order to solve the above-described conventional problems, a program execution control apparatus according to the present invention includes a compiler, an interpreter, and a JIT compiler that performs a separate task, and sequentially reads and interprets intermediate code generated from source code. A program execution control device, comprising: a method information management unit that holds the JIT compilation status of the intermediate code by the JIT compiler as method information for each method; and access to the method information held in the method information management unit. A method information updating means for controlling, a JIT compilation status judging means for judging whether or not the JIT compilation status has reached a turning point based on the method information held in the method information management means, and the interpreter The execution of the intermediate code is the method If the method called in the method information management means is referred to and the called method is being compiled and the JIT compilation status has not reached the turning point The intermediate code is selected to be sequentially interpreted and executed by the interpreter, and when the turning point has been reached, the native code is executed after waiting for the JIT compiler to complete the conversion to the native code. And a program control means for selecting.

  With this configuration, when a method is called, it is possible to select whether to execute native code or to perform interpreter processing based on the progress of JIT compilation of the method, and to appropriately switch processing.

  According to the program execution control apparatus of the present invention, when the called method is in the middle of JIT compilation, the processing system overhead is reduced by appropriately switching the processing based on the JIT compilation status of the method. Can do.

The figure which shows the structure of the program execution control apparatus in embodiment of this invention The figure which shows the structure of the program execution means in embodiment of this invention The figure which shows the flow of operation | movement of the program control means in embodiment of this invention

  Hereinafter, embodiments of the present invention will be described with reference to the drawings.

  FIG. 1 is a schematic diagram of a configuration of a program execution control device according to an embodiment of the present invention.

  In the figure, reference numeral 101 denotes a program execution control device of the present invention. The program execution control device 101 is a program compiled into native code unique to the CPU on which it runs, and resides on the memory system to execute the source code. That is, the program execution control apparatus 101 performs compilation from source code to intermediate code, sequential reading of intermediate code and sequential execution by an interpreter, JIT compilation from intermediate code to native code, and execution of native code.

  In the figure, reference numeral 102 denotes a source code string that is a collection of program codes. The source code sequence 102 itself is a program code of an application program, and is executed by an arbitrary CPU through the program execution control device 101.

  In the figure, reference numeral 103 denotes an intermediate code string that is a collection of intermediate codes. The program execution control apparatus 101 generates an intermediate code string 103 from the source code string 102. Similar to the source code sequence 102, the intermediate code sequence 103 moves by the intervention of the program execution control device 101.

  In the figure, reference numeral 104 denotes a native code string that is a collection of native codes unique to the CPU. The program execution control apparatus 101 compiles each method from the intermediate code string 103 to generate native code.

  These source code sequence 102, intermediate code sequence 103, and native code sequence 104 are also on the memory system of the computer system.

  In the figure, reference numeral 105 denotes a compiler for converting the source code string 102 into the intermediate code string 103. The compiler 105 generally performs the conversion from the source code string 102 to the intermediate code string 103 in a lump before sequential execution of the intermediate code.

  When compiling from the source code sequence 102 to the intermediate code sequence 103, the compiler 105 gives an intermediate code size for each method in the intermediate code. The intermediate code size is registered in a method information management table 201, which will be described later, when the method is called, and is used for the subsequent JIT compilation status determination.

  The compiler 105 may be separated from other parts of the program execution control apparatus 101. For example, the server side compiles from the source code sequence 102 to the intermediate code sequence 103. A configuration in which the client side acquires the intermediate code sequence 103 from the server side via the network and executes the program execution control device 101 installed on the client side is also possible.

  In the figure, reference numeral 106 denotes program execution means, which represents a program for controlling the program execution control apparatus 101. The program execution means 106 has a function of selecting and switching native code execution or interpreter processing based on the JIT compilation status of the method when the method is called.

  In the figure, reference numeral 107 denotes an interpreter of the program execution control apparatus 101, which sequentially interprets and executes the intermediate code read by the program execution means 106.

  In the figure, reference numeral 108 denotes a JIT compiler of the program execution control apparatus 101, which performs conversion from intermediate code to native code for each method.

  The program execution means 106, interpreter 107, and JIT compiler 108 will be described below.

  The program execution means 106 instructs the compiler 105 to convert the source code string 102 to the intermediate code string 103. As described above, this part may be separated from the program execution control apparatus 101, and is not limited to being compiled into the intermediate code string 102 according to an instruction from the program execution means 106.

  Next, the program execution means 106 sequentially reads the intermediate code string 103 and processes it by the interpreter 107. When the method call is reached, the program execution means 106 selects whether to read the intermediate code of the method from the intermediate code string 103 and interpret it, or to execute the native code of the method in the native code string 104.

  When the intermediate code of the method is interpreted, it is sequentially executed by the interpreter 107.

  Here, interpreting the intermediate code refers to causing the CPU to execute native code corresponding to the intermediate code read in a small amount of processing units. That is, the interpreter 107 manages, for each type of intermediate code, what native code is executed by the CPU when it is read. Then, the interpreter 107 causes the CPU to sequentially execute the native code corresponding to the intermediate code read sequentially.

  On the other hand, to execute the native code of the method, the program execution means 106 manages the address of the memory system where the native code of the method is located. This corresponds to the program execution means 106 setting the address in the program counter of the CPU.

  Further, the program execution means 106 determines whether or not to JIT-compile the intermediate code of the method at the time of calling the method. In the case of JIT compilation, the JIT compiler 108 is instructed to perform JIT compilation of the method.

  The interpreter 107 interprets and executes the sequentially read intermediate code sequence 103 in accordance with instructions from the program execution means 106. The interpreter 107 measures the interpreter processing time for each method, and notifies the program execution means 106 of it.

  The JIT compiler 108 receives a JIT compilation instruction from the program execution means 106 and performs JIT compilation from the intermediate code to the native code unique to the CPU. In the program execution control apparatus 101, the JIT compilation from the intermediate code to the native code is performed in parallel with a task different from the program execution task such as interpreter processing and execution of the native code.

  Further, the JIT compiler 108 notifies the program execution means 106 of the compiled size of the intermediate code, and the program execution means 106 updates and holds it for each method. The notification of the intermediate code compiled size from the JIT compiler 108 is performed at a timing when a certain time has passed or when a JIT compilation of a certain size has been completed.

  The JIT compiler 108 measures the JIT compilation speed (JIT compilation time per unit size of intermediate code) and notifies the program execution unit 106 of it. This is used by the JIT compilation status determination unit 203 described later to estimate the remaining time required until the end of JIT compilation. The JIT compilation speed is not limited to the latest one, but may be smoothed by taking an average value for a certain period. The JIT compiler 108 notifies the program execution means 106 of the end of JIT compilation.

  In the following, the configuration of the program execution means 106 is shown in FIG.

  In the figure, reference numeral 201 denotes a method information management table, in which information on the method called when the intermediate code is executed is registered for the first time, and is updated thereafter.

  In the figure, reference numeral 202 denotes a method information management table update unit, which controls access (read / write) to the method information management table.

  In the figure, reference numeral 203 denotes JIT compilation status determination means for determining the JIT compilation status of the method registered in the method information management table.

  In the figure, reference numeral 204 denotes program control means for performing overall control of the program execution means 106 and data input / output of the program execution means 106.

  The program execution means 106 is a program itself. Further, the method information management table 201, the method information management table update unit 202, the JIT compilation status determination unit 203, and the program control unit 204 described above are classified and specified for each function in order to explain the outline of the program execution unit 106 It is a component.

  Hereinafter, operations of the method information management table 201, the method information management table update unit 202, the JIT compilation status determination unit 203, and the program control unit 204 will be described.

  The registration column of the method information management table 201 registers whether the method information of the line is valid. Here, 1'b0 represents invalidity and 1'b1 represents valid. All lines have an initial value of 1'b0 and are updated to 1'b1 when method information is newly registered. When the method information of the line is discarded, it is updated to 1'b0.

  Although the method information discarding method is not described here, it is only necessary to separately manage the method invocation tendency and discard information from the method that is no longer invoked.

  In the method ID column of the method information management table 201, a method ID for uniquely identifying a method is registered by the method information management table updating unit 202 according to an instruction from the program control unit 204.

  In the following description, it is assumed that the method information management table updating unit 202 directly refers to and updates the method information management table.

  In the interpreter processing count column of the method information management table 201, an initial value 1 is registered when new method information is registered, and is incremented each time the method is interpreted. In addition, when the threshold value is provided in the frequency | count of an interpreter process and it uses for a compile start condition, you may stop an increment with the threshold value.

  In the interpreter processing time column of the method information management table 201, the interpreter processing time for each method notified from the interpreter 107 to the program control means 204 is registered and updated.

  Note that the interpreter 107 measures the interpreter processing time, notifies the interpreter 107 of the processing time, registers in the interpreter processing time column, and updates only during the period in which the JIT compilation status column of the method is 2'b01. May be. This is because the interpreter processing time is used only for determination when the JIT compilation status determination unit 203 changes the JIT compilation status from 2'b01 to 2'b10. Further, the interpreter processing time is not limited to the latest value, and may be smoothed to some extent by taking an average value several times. Further, measurement and updating may be performed every several interpreter processes, and it is not necessary to perform each time.

  In the intermediate code size column of the method information management table 201, a value assigned in the intermediate code string 103 is read by the program control unit 204 when a method is called and registered when method information is newly registered.

  In the intermediate code compiled size column of the method information management table 201, an initial value of 0 is registered when a method is newly registered, and thereafter updated with the compiled size notified from the JIT compiler 108 to the program control means 204.

  The JIT compiler 108 may accumulate the compiled size, notify the compiled size, and update the intermediate code compiled size column only during the period in which the JIT compilation status column of the method is 2'b01. This is because the intermediate code compiled size is used only for determination when the JIT compilation status determination unit 203 changes the JIT compilation status from 2'b01 to 2'b10.

  In the JIT compilation status column of the method information management table 201, 2'b00 is registered as an initial value when a method is newly registered, and is updated as compilation proceeds thereafter.

  In this example, 2'b00 in the JIT compilation status column is in an uncompiled state, 2'b01 is being compiled and has not reached a turning point, and 2'b10 is being compiled and has reached a turning point. 2′b11 represents a state in which compilation is finished.

  When the program control unit 204 determines the start of JIT compilation of the method, the value in the JIT compilation status column of the method information management table 201 corresponding to the method is updated from 2'b00 to 2'b01. Thereafter, when JIT compilation proceeds and the JIT compilation status determination means 203 determines that the turning point has been reached, the value in the JIT compilation status column is updated from 2'b01 to 2'b10. Thereafter, at the end of JIT compilation, the value in the JIT compilation status column is updated from 2'b10 to 2'b11.

  In the address field of the native code of the method information management table 201, the address of the memory system where the native code after JIT compilation is stored is notified from the program control means 204 at the start of JIT compilation of the method and registered. .

  The method information management table update unit 202 controls access to the method information management table 201 from the program control unit 204. When new method information is registered, the method ID and intermediate code size are received from the program control means 204 and registered in the line whose value in the registration column of the method information management table 201 is 1'b0.

  Also, the method information management table updating unit 202 sets the value of the interpreter processing count column to 1, the intermediate code compiled size value to 0, and the JIT compilation status value to 2'b00 when newly registering method information. Initialize to.

  Further, the method information management table update unit 202 appropriately receives and updates the interpreter processing time from the program control unit 204.

  Also, the method information management table updating unit 202 receives and registers the address of the native code at the start of JIT compilation.

  If smoothing or the like is performed when updating the interpreter processing time column of the method information management table 201, it may be performed by the method information management table update unit 202.

  The method information management table update unit 202 notifies the program control unit 204 of the number of interpreter processes. The program control unit 204 determines the start of JIT compilation of the method based on the number of interpreter processes. Note that the notification timing of the interpreter processing count may be performed at the timing of access from the program control means 204.

  Further, the method information management table updating unit 202 uses the JIT compilation status determination unit 203 to determine the JIT compilation status. The determination is made only for a method whose value in the JIT compilation status column is 2'b01, and determines whether JIT compilation has reached a turning point. At this time, the method information management table update unit 202 passes the interpreter processing time, the intermediate code size, and the intermediate code compiled size of the determination target method to the JIT compilation status determination unit 203. After the determination, the method information management table updating unit 202, when notified from the JIT compilation status determination unit 203 that the turning point has been reached, changes the JIT compilation status of the method information management table from 2′b01 to 2′b10. change.

  The JIT compilation status determination unit 203 determines whether to change the value of the JIT compilation status column from 2′b01 to 2′b10 when the intermediate code compiled size of the method information management table 201 is updated. I do.

  The determination of the JIT compilation status may be performed in synchronization with the update of the interpreter processing time, or may be synchronized with both the update of the intermediate code compiled size and the update of the interpreter processing time.

  The JIT compilation status determination unit 203 holds the JIT compilation speed notified from the JIT compiler 108 via the program control unit 204, and uses it to estimate the remaining time required until the end of JIT compilation.

  The following is an example of a flow from when the JIT compilation status determination unit 203 estimates the remaining time required for the end of JIT compilation and the execution time of the native code to determine whether the JIT compilation has reached a turning point. .

  As shown in FIG. 2, in the method whose method ID is method1 registered in the method information management table 201, the interpreter processing time is 1100 [ms]. The intermediate code size is 10200 [bytes], and the intermediate code compiled size is 2500 [bytes].

  Assume that the compilation speed held by the JIT compilation status determination unit 203 is 0.2 [ms / byte], and the execution time of the native code is estimated by multiplying the interpreter processing time by 0.05.

  The JIT compilation status determination unit 203 receives the interpreter processing time, the intermediate code size, and the intermediate code compiled size from the method information management table update unit 202, and estimates the remaining time required until the end of JIT compilation.

  At this time, the remaining amount of JIT compilation is 10200 [bytes] -2500 [bytes] = 7700 [bytes]. For this reason, the remaining time required until the end of JIT compilation is 7700 [bytes] × 0.2 [ms / byte] = 1540 [ms].

  Further, the JIT compilation status determination unit 203 estimates the execution time of the native code as 1100 [ms] × 0.05 = 55 [ms].

  Here, the necessary remaining time is (remaining time necessary until the end of compilation) + (native code execution time) = 1540 [ms] +55 [ms] = 1595 [ms]. In this case, the necessary remaining time is longer than the interpreter processing time 1100 [ms].

  Therefore, the JIT compilation determination unit 203 determines that the turning point has not been reached during compilation, and notifies the method information management table update unit 202 of the result. In this situation, when a method whose method ID is method1 is called, the program control unit 204 selects execution by interpreter processing in the interpreter 107.

  On the other hand, in the method whose method ID is method3 registered in the method information management table 201, the interpreter processing time is 2300 [ms], the intermediate code size is 33240 [bytes], and the intermediate code compiled size is 24000 [bytes]. It is.

  Similarly, the remaining time required until the end of JIT compilation is (33240 [ms] −24000 [ms]) × 0.2 = 1848 [ms]. The native code execution time is 2300 [ms] × 0.05 = 115 [ms]. That is, the necessary remaining time is (remaining time required until the end of JIT compilation) + (native code execution time) = 1848 [ms] +115 [ms] = 1963 [ms]. In this case, the necessary remaining time is shorter than the interpreter processing time 2300 [ms].

  Therefore, the JIT compilation status determination unit 203 determines that a turning point has been reached during compilation. As a result, the JIT compilation status column of method3 is updated to 2'b10.

  After updating the JIT compilation status column, when a method whose method ID is method3 is called, the program control unit 204 selects execution of the native code of the method.

  Note that the method by which the JIT compilation status determination unit 203 estimates the execution time of the native code is not limited to the above method, and may be estimated by another method such as multiplying the intermediate code size by a certain value. Alternatively, the execution time of the native code is a relatively small value and may be ignored.

  In the case where the native code is executed after the end of JIT compilation, it is possible to control such that the allocation of CPU resources and memory resources to the JIT compilation task is temporarily increased until the end of JIT compilation. This is because the execution task transitions to idle. In such a case, the actual JIT compilation speed is faster than the JIT compilation speed held in the JIT compilation status determination unit 203. For this reason, the JIT compilation status determination unit 203 may estimate the remaining time required for completion of compilation after correcting the held JIT compilation speed.

  For methods with a relatively small intermediate code size, the interpreter processing time and JIT compilation time are considered to be short. Therefore, the program control unit 204 may perform processing by providing a threshold value for the intermediate code size. For example, the program control unit 204 updates the interpreter processing time and the intermediate code compiled size as described above only for the method that exceeds the threshold, and determines whether the JIT compilation status determination unit 203 has reached a turning point. judge. In this case, for a method with a small size that is equal to or smaller than the threshold, when it is called during JIT compilation, it is fixedly determined whether to execute by interpreter processing or wait for the end of JIT compilation to execute native code. do it.

  The program control means 204 is a series of programs including instructions for compiling source code to the compiler 105, sequential reading of intermediate code and sequential processing using the interpreter 107, instructions for JIT compilation to the JIT compiler 108, and execution of method native code. Control execution.

  As described above, the program control unit 204 receives the interpreter processing time, JIT compilation speed, and intermediate code compiled size from the interpreter 107 and the JIT compiler 108. Further, the program control unit 204 passes the received information to the method information management table update unit 202 and the JIT compilation status determination unit 203.

  Further, when reaching the method call, the program control unit 204 determines whether to interpret the method or execute the native code of the method.

  Here, the flow of the operation of the program control means 204 from the method call is shown in FIG. 3, and the difference from the prior art program execution control device described in the preceding example is clarified.

  Here, the method call is the second and subsequent times, and the method information management table 201 shows that the method information has already been registered. Incidentally, in the case of the first method call, first the initial value of the method is newly registered, and the program control means 204 selects execution of the method in the interpreter process. When the method is called for the first time, the method information management table 201 is not registered with the method information.

  When the method is called, the program control unit 204 refers to the method information management table 201 via the method information management table update unit 202 (step S300).

  If the JIT compilation status column of the method information management table 201 is 2'b11 and indicates that the method has been compiled (YES in step 301), the native code of the method is executed (step 302).

  If the JIT compilation status column of the method information management table 201 is 2′b10 and indicates that the turning point has been reached during compilation (NO in step 301 → YES in step 303 → YES in step 304) ), Wait until the end of JIT compilation (step 305), and execute the native code of the method (step 302).

  If the JIT compilation status column of the method information management table 201 is 2′b01, indicating that the turning point has not been reached during compilation (NO in step 301 → YES in step 303 → NO in step 304) ), The interpreter 107 selects to sequentially process the intermediate code of the method (step 308).

  If the JIT compilation status column of the method information management table 201 is 2′b00, indicating that it has not been compiled (NO in step 301 → NO in step 303), the number of interpreter processes in the management information table 201 Whether or not the method should be newly JIT-compiled is determined from the value in the field of (No. S306). If it is determined that a new JIT compilation is to be performed (YES in step 306), the JIT compiler 108 is instructed to perform JIT compilation of the method, and the interpreter 107 selects to sequentially process the intermediate code of the method (step). 308). If it is determined not to perform JIT compilation (NO in step 306), the interpreter 107 selects to sequentially process the intermediate code of the method (step 308).

  As described above, the program execution control apparatus according to the present invention appropriately selects whether to execute native code or perform interpreter processing based on the JIT compilation status of the method when a method during JIT compilation is called. it can. With this selection, it is possible to select a shorter execution time in selecting whether to execute the native code after waiting for the end of JIT compilation or to immediately move to the interpreter process of the intermediate code. As a result, it is possible to eliminate the overhead that has occurred when either one is fixedly selected. In addition, it is easy to adopt a configuration in which JIT compilation of intermediate code is run as a low priority task in parallel with the execution task, and the response performance of the program can be maintained.

  The program execution control device of the present invention is useful as a virtual computer including an interpreter and a JIT compiler. The present invention can also be applied to various home appliances incorporating this virtual machine, communication equipment such as mobile phones, industrial equipment, and passenger equipment.

101 program execution control device 102 source code sequence 103 intermediate code sequence 104 native code sequence 105 compiler (source code → intermediate code)
106 Program Execution Means 107 Interpreter 108 JIT Compiler (Intermediate Code → Native Code)
201 Method Information Management Table 202 Method Information Management Table Update Unit 203 JIT Compilation Status Determination Unit 204 Program Control Unit

Claims (5)

A program execution control device that includes a compiler, an interpreter, and a JIT compiler that performs separate tasks, sequentially reads intermediate code generated from source code, interprets and executes the program,
Method information management means for holding the JIT compilation status of the intermediate code by the JIT compiler as method information for each method;
Method information update means for controlling access to method information held in the method information management means;
JIT compilation status determination means for determining whether or not the JIT compilation status has reached a turning point based on the method information held in the method information management means;
When the execution of the intermediate code by the interpreter reaches a method call, the method information held in the method information management means is referred to, the called method is being compiled, and the JIT compilation status Is not reached the turning point, it is selected to sequentially interpret and execute the intermediate code by the interpreter. When the turning point has been reached, the conversion to the native code by the JIT compiler is terminated. A program execution control apparatus comprising program control means for selecting to execute the native code after waiting. The program execution control apparatus according to claim 1, wherein the method information includes an intermediate code size, an intermediate code compiled size, an interpreter processing time, and a JIT compilation status. The program execution control apparatus according to claim 1, wherein the program control unit selects to execute the compiled native code when the called method is compiled. The JIT compilation status determination means determines the remaining amount necessary until the end of JIT compilation from the intermediate code size included in the method information, the intermediate code compiled size, and the JIT compilation speed notified from the JIT compiler. Estimate the time and the execution time of the native code, and if the total time of the remaining time required to complete the JIT compilation and the execution time of the native code is shorter than the interpreter processing time, the turning point is reached. 3. The program execution control device according to claim 2, wherein when the total time is not shorter than the interpreter processing time, it is determined that the turning point has not been reached. 5. The program execution control device according to claim 4, wherein when compiling the source code into the intermediate code, the compiler assigns the intermediate code size for each method in the intermediate code.

Images