WO2001013223A1

WO2001013223A1 - Method and apparatus for operating virtual computer

Info

Publication number: WO2001013223A1
Application number: PCT/JP2000/005540
Authority: WO
Inventors: Ryota Kunisawa
Original assignee: Access Co., Ltd.
Priority date: 1999-08-18
Filing date: 2000-08-18
Publication date: 2001-02-22
Also published as: AU6595700A; JP2001056764A

Abstract

The loop part repeated during execution of an intermediate code (111) is detected dynamically during the execution and the intermediate code of the loop part is converted into a native code (112). The native code (112) is executed directly by means of a CPU (10) for the loop part of the intermediate code. More specifically, an instruction for directing the control flow upward is detected when the intermediate code (111) is loaded in a memory (11) and rewritten into a first special instruction when it is detected. When the intermediate code (111) in the memory (11) is executed, the jump destination of control is confirmed before the first special instruction is executed. If the jump destinations of control agree with each other when the same first special instruction is executed again, the jump destination judges that the branch point is the loop part and converts the bite code (111) of the loop part is converted into the native code (112). The time required to convert the intermediate code (111) into the native code (112) is shortened and the overall execution speed is enhanced even in an apparatus having a relatively small memory capacity.

Description

Specification

Method and apparatus for executing a virtual machine

The present invention relates to a method and an apparatus for executing a virtual machine for executing an intermediate code called a note code. Background art

As such a virtual machine, Java VM (Java is a trademark of Sun Microsystems) is known.

As shown in Figure 10, a program (source code) written in the Java language is compiled and converted into intermediate code called a byte code. Byte code is suitable for distributing programs over a network because it does not depend on specific hardware or OS (Operating System) and is relatively small in size. It is also suitable for use as software for embedding in specific devices. The bytecode is not executed directly by the CPU of each computer, but by a virtual machine, which is an engine created by software. The code that cpu can execute directly on the note code is called native code.

Since bytecode is analyzed and executed sequentially by software, it has the disadvantage of slow execution speed. Conventionally, a JIT (Just In Time) compiler has been known as a method for solving this problem. This converts the byte code into native code (this process is also referred to as compiling) is for ^five rows directly CPU force the native code.

However, this JIT had the following problems. First, it takes time to compile this bytecode into native code. Second, the size of native code is larger than that of bytecode, which is a problem for embedded and consumer devices with relatively small memory capacity and relatively low CPU speed. The present invention has been made in such a background, and its object is to However, a virtual computer execution method and apparatus that can reduce the processing time for converting intermediate code to native code and can generally improve the execution speed even on a device with a relatively small memory capacity are proposed. To provide. Disclosure of the invention

A method according to the present invention is a method for executing a virtual machine that executes intermediate code, comprising: dynamically detecting a loop portion repeatedly executed during execution of the intermediate code during the execution; It is characterized by comprising a step of converting code into native code, and a step of directly executing the native code by a CPU for the loop portion of the intermediate code.

According to the present invention, the loop portion can be reliably detected by dynamically detecting the loop portion during execution of the intermediate code. Also, since only the loop part is converted to native code, the time required for the conversion is relatively short, and the memory capacity for holding the native code is relatively small.

More specifically, when the intermediate code is loaded into a memory, an instruction whose control flow is upward is detected, and when the instruction is detected, the instruction is rewritten to a first special instruction. When executing the intermediate code on the memory, the control jumps when executing the first special instruction, confirms the destination, and when the same first special instruction is executed again, the control jumps. If they match, it is determined that the jump source from the jump destination is the loop portion, and the intermediate code of the loop portion is converted into a native code. In this way, when loading the intermediate code, it is possible to incorporate in the intermediate code the work for detecting the loop portion during later execution.

However, the step of rewriting to the first special instruction may be performed at the time of execution instead of at the time of loading the intermediate code.

Counting the number of times the jump destinations match, and when the count value reaches a predetermined value, further determines whether or not the loop portion can be converted to native code according to a predetermined determination criterion. When the condition is satisfied, the conversion to the native code may be performed. This makes it possible to set more appropriate conditions for conversion to native code depending on the application and application. The criteria are satisfied If not, by returning the first special instruction to the original ordinary instruction, it is possible to prevent the loop from performing useless processing related to conversion to native code thereafter.

When loading the intermediate code into the memory, an instruction that changes the control flow other than the “instruction for upward control flow” is detected, and when the instruction is detected, the instruction is converted to a second special instruction. The method may further include a step of rewriting, and a step of invalidating the jump destination information at the time of executing the second special instruction when executing the intermediate code on the memory. This corresponds to a case where the loop processing has not been performed or has been interrupted, and this configuration prevents the subsequent useless processing from being performed as described above.

The step of rewriting to the second special instruction may be performed at the time of execution instead of at the time of loading the intermediate code.

An apparatus according to the present invention for performing the above method is an execution device of a virtual machine for executing intermediate code, comprising: a CPU for executing native code; a memory for storing intermediate code; Means for loading code; interpreting and executing the intermediate code; virtual computer means on the CPU; and a loop portion repeatedly executed when the intermediate code is executed by the virtual computer means. Means for dynamically detecting the intermediate code of the loop portion into native code, and executing the native code directly by the CPU for the loop portion of the intermediate code. And

BRIEF DESCRIPTION OF THE FIGURES

FIG. 1 is a conceptual diagram of an execution method of a virtual machine according to the present invention.

FIG. 2 is a block diagram showing a hardware configuration of an apparatus in which the method of the present invention is performed.

FIG. 3 is a flowchart of a process performed when a bytecode is loaded on a memory in the embodiment of the present invention.

FIG. 4 is a flowchart of a process at the time of executing a program according to the embodiment of the present invention. 5 is a flowchart showing the operation of the system.

Figure 5 shows an example of a very simple source program with one basic block.

FIG. 6 is a diagram showing an example of a bytecode obtained by compiling the source program of FIG.

FIG. 7 is a diagram showing a state in which the instruction in the bytecode string in FIG.

FIG. 8 is a diagram showing a state in which the instruction at the head of the loop in the bytecode string in FIG. 7 has been rewritten as “instruction for jumping to native code”.

FIG. 9 is a flowchart showing a flow chart of a process at the time of executing a program according to another embodiment of the present invention.

Figure 10 is a conceptual diagram showing how a program (source code) written in the Java language is compiled and converted to intermediate code called a byte code. BEST MODE FOR CARRYING OUT THE INVENTION

Hereinafter, embodiments of the present invention will be described in detail.

FIG. 1 is a conceptual diagram of an execution method of a virtual machine according to the present invention. An application program (source code) 20 written in Java language or the like is converted into a class file 21 composed of an intermediate code (byte code) by a compiler. A class is a block of a program including a plurality of functions (called methods) for realizing various functions, and a plurality of class filters ⁵ can be created for one application. The intermediate code of each class file is loaded into memory 11 before execution. At the time of loading, it is possible to perform a special operation to detect the loop portion that is repeatedly executed when executing the byte code during program execution. This specific example will be described later.

The byte code 111 on the memory 11 is sequentially interpreted and executed by a virtual machine (VM) 101 on the CPU 10. During this execution, if a loop portion is detected based on the above trick, the bytecode of the loop portion is changed to native code 112. And put it on memory 1 1. When this loop is executed, the CPU 10 directly executes the native code instead of executing the bytecode by the virtual machine 101. As will be described later, the above “work” can be performed during execution.

Usually, the size of such a repetition part is relatively small, so the time required to convert the bytecode to native code is small. Also, since the size of the native code 112 corresponding to only the loop portion can be small, the large capacity of the memory 11 due to the native code 112 does not occur.

FIG. 2 is a block diagram showing a hardware configuration of an apparatus for executing the method of the present invention. This is a general computer system, which includes CPU 10, memory 11, external storage device (such as hard disk) 12, input device 13 such as keyboard, display device 14, Internet device and external device. Communication interface 15.

FIG. 3 is a flowchart of a process performed when a note code is loaded on a memory.

First, find the entry of one function (S11). If there are multiple functions in the bytecode program to be loaded, the following processing is repeated until there are no unprocessed functions (S12).

If there is a function, first find the first instruction in the function (S13). Check if this instruction is an “upward instruction”, that is, an instruction to return control to the top of the program (S14, Yes). This can be determined based on the description before executing the instruction. If the instruction is an upward instruction, the instruction is rewritten as an instruction for performing profiling (first special instruction) (S17). This first special order adds the ability to profile “upward orders”. Here, a "profile" is generally a force that is information about how many times a particular basic block or a particular line in the source has been executed, and if there are branches, in which direction and how many times. ^s ', where the code location of the branch, and where and how many times it jumped. “Profile” refers to confirming and storing such information.

Then, the process proceeds to step S16 described later. In step S14, the instruction If it is not the "command to head", it is checked whether it is a "command to change the flow of other controls" (S15). This “instruction that changes the flow of control” corresponds to a case where the loop exits at a place other than the end condition in the loop. In the case of such an instruction, the instruction is rewritten as “an instruction for invalidating the profile” (S 18). This instruction also adds the functionality s to invalidate the function of the original instruction. The reason for disabling the profile here is that even if a “profile” was created for the “upward instruction” first by “an instruction to change the flow of control”, the “upward instruction” would not This is because it became clear that the repetition of the loop was not executed.

In step S15, if the instruction is not an "instruction to change the flow of control", it is checked whether the end of the function has been reached (S16). If the end has not been reached, step S1 is executed. Returning to step 3, the above processing is repeated.

In this way, the trick to find the loop dynamically when executing the program (paragraphs, it code) described below was done at the time of the mouth.

FIG. 4 shows a flowchart of a process when the program is executed.

In this process, first, the first bytecode instruction is obtained (S31), and it is checked whether or not this instruction is an "instruction for performing profiling" (S32). If so, create a profile (S33). It is checked whether or not this profile (particularly, the branch destination) matches the profile stored earlier (S34). If they do not match, the previous profile is overwritten with the new profile obtained this time (S39). When the first command to perform profiling appears, there is no “first profile”, so the current profile is stored as it is. In step S34, if the current profile matches the previous profile, it can be determined that the flight has jumped from the same source to the same destination, so the counter (variable) is incremented (S35). The initial value is set to "0". Until the counter value reaches a predetermined value (predetermined value), the process goes to step S44, bypassing steps S37 and S38.

Waiting for a predetermined number of loop iterations is empirical or based on the contents of the application when the number of loop iterations reaches the predetermined number of times. Is based on the assumption that the repetitive force s will continue, and if the repetition does not reach the predetermined number of times, there is a high possibility that the repetitive force stops or the flow changes. Thus, the "predetermined value" of the counter may change from case to case. When the counter value reaches a predetermined value, it is determined whether or not it is worth compiling the loop portion (from the jump destination to the jump source) (S37). The details of this determination will be described later. If it is judged that it is not worth compiling, the “instruction to perform profiling” is returned to the original ordinary instruction (instruction without the above additional functions) (S38) o

If it is determined that the compilation is worthwhile, the bytecode of the loop is compiled to create native code (S41). Next, the first bytecode instruction of this loop is rewritten to an instruction for jumping to the native code (S42). After that, the native code is directly executed by CPU for this loop part. After executing the native code, it returns to the bytecode instruction following the last bytecode instruction in the loop. Therefore, the "instruction to do the opening file" at the end of the loop is bypassed.

Note that even after exiting the loop, the relevant native code is preserved, and the same native code is used the next time the same loop is re-entered. If the native code created once is saved in this way, the memory capacity of the native code may eventually become excessive, so the maximum capacity of the memory for storing the native code is determined in advance. Avoid generating native code that exceeds this. Alternatively, keep track of the number of executions of each natively coded loop, and if the maximum memory capacity is exceeded, disable the native code of the loop with the lowest number of executions. Well ,.

In step S32, if the instruction is not the “instruction to perform profiling”, and if the instruction is “instruction to invalidate profile” (S43, Yes), the profile information currently stored is invalidated. Yes (S45).

If it is not the "instruction to invalidate the profile", the instruction is executed (S44). After the previous steps S38, S45, S42, the process also proceeds to step S44. After step S44, return to the first step S31 and follow the byte code The above process is repeated for the instruction.

The judgment conditions for deciding whether or not to execute the compilation in step S37 will be described. The following two are examples of such judgment conditions.

(a) Compare the loop inner size with the native code read overhead. The size inside the loop is determined by the number of instructions of the bytecode, and by multiplying this by an appropriate value, the time required for actually executing one loop can be estimated. The overhead of reading native code is the time spent in extra code that must be executed to execute the native code. This is not constant, but is assumed to be. If it is smaller than "overhead + time to execute native code on CPU" s If it is smaller than "the size of the inside of the loop", it is judged that compiling should be performed because executing the native code saves time. Otherwise, it is determined that the compilation is not performed because the byte code executed by the virtual machine is ⁵ 'faster. Note that, in the above-described determination conditions, “the time for executing the native code by the CPU” is regarded as 0.

(b) Multiply by the number of jumps (the number of times the loop was executed) by the size inside the loop and compare it with the static size of the code inside the function. Here, “the size inside the loop” is as described above. By multiplying the number of jumps by the “size inside the loop”, the time consumed when the bytecode instruction inside the loop is executed by the virtual machine is estimated. "Static size of code inside function" estimates "time to execute loop only once + execution time of parts other than loop". “Loop size” and “Static size of code inside a function” indicate the percentage of time the loop executes in the function. If this ratio is large, it is determined that it should be compiled. This is because if the time to execute a specific loop is longer than the time to execute a certain function, the contribution of improving the execution speed by compiling the loop increases.

The above judgment conditions (a) and (b) may be employed independently or may be employed under AND conditions. Also, if some number of iterations force of the ^loop? Expected, the effect of reducing the execution time can be expected that the embodiment does not perform the determination of both conditions it is also contemplated. That is, the above step S37 is deleted, and the counter value reaches a predetermined value. Then, the conversion to the native code may be performed immediately.

Hereinafter, a specific program example will be described with reference to FIGS.

Figure 5 shows an example of a very simple source program with one basic block. In this example, for the integers i, a, and b, the initial values of a and b are 0 and 1 0 0 0, respectively, and starting from i = 0, assigning the value of a + b to a and incrementing i When the value of i reaches 100, the process exits from this loop.

Figure 6 shows an example of a bytecode obtained by compiling this source program. In this example, the variable i is assigned to var [8], a is assigned to var [9], and b is assigned to var [10]. The code for initializing variables a and b is omitted. The loop from address 34 to address 52 in Figure 6 is the loop, which is the target of compilation into native code.

Since there is an instruction at address 49 to address 34 above at the time of these byte code strings, as shown in FIG. 7, the instruction power of this address 49 ^s Is rewritten as In addition, there is no “instruction to invalidate a profile”.

When the byte code sequence program shown in FIG. 7 is executed by the virtual machine, the loop portion from address 34 to address 52 is returned a predetermined number of times, and the corresponding portion is converted to native code by compiling. After conversion, the instruction at address 34 at the beginning of the loop is rewritten as “instruction to jump to native code” as shown in FIG. Specific examples of the native code differ depending on the CPU used, and have a large capacity.

FIG. 9 shows a process flow when a program is executed in another embodiment according to the present invention. In the previous embodiment, when the bytecode was loaded (FIG. 3), the work for detecting the loop portion was performed. In this embodiment, the processing in FIG. 3 is included in the program execution processing. is there. By doing so, the time required until the program execution starts can be reduced. This is suitable for cases where the startup is fast but you don't care much about the time it takes to run (eg for interactive processing). On the other hand, in the above embodiment, It is suitable for cases where it is necessary to reduce the processing time during execution as much as possible (for example, in the case of real-time processing).

In FIG. 9, specifically, among all steps S51 to S71, processing steps S54, S55, S58, and S60 at the time of loading the program in the previous embodiment are described. It is. Steps S52 to S56 are in no particular order. In the error processing in step S57, when an impossible instruction is detected, the instruction is skipped or the virtual machine is abnormally terminated. This step may be included in the processing of FIG. 4 not shown in the execution processing of FIG.

The preferred embodiment of the present invention has been described above, but various modifications and changes can be made without departing from the gist of the present invention. For example, although the processing of the JaVa application has been described above, the present invention can be similarly applied to a virtual machine built in a Web browser that processes a so-called program. Industrial applicability

According to the execution method and apparatus of the present invention, the conversion processing time from the intermediate code to the native code can be reduced, and the execution speed can be generally improved even in an apparatus having a relatively small memory capacity. .

Claims

The scope of the claims

1. A method of executing a virtual machine that executes intermediate code,

Dynamically detecting, during the execution of the intermediate code, a loop portion that is repeatedly executed;

Converting the intermediate code of the loop portion into native code; and executing the native code directly by CPU for the loop portion of the intermediate code;

A method for executing a virtual machine, comprising:

2. When loading the intermediate code into the memory, detecting an instruction whose control flow is upward, and rewriting the instruction to a first special instruction upon detecting the instruction;

When executing the intermediate code on the memory, the control jump destination is checked when the first special instruction is executed, and the control jump target power ^s — when the same first special instruction is executed again. If so, determining that the jump source from the jump destination is the loop portion, and converting the intermediate code of the loop portion into native code;

2. The method for executing a virtual machine according to claim 1, comprising:

3. The method according to claim 2, wherein the step of rewriting the first special instruction is performed at the time of execution instead of at the time of loading the intermediate code.

4. Count the number of times the jump and the end match, and when the count value reaches a predetermined value, determine whether or not the loop part can be converted to native code according to predetermined criteria. 4. The method according to claim 2, wherein the conversion to the native code is performed when the judgment criterion ^{s is} satisfied.

5. The method according to claim 4, wherein the first special instruction is returned to an original ordinary instruction when the judgment criterion is not satisfied.

6. When loading the intermediate code into the memory, an instruction that changes the control flow other than the “instruction for upward control flow” is detected, and when the instruction is detected, the instruction is changed to a second special instruction. Rewriting to the instruction of

When executing the intermediate code in the memory, invalidating the jump destination information at the time of executing the second special instruction;

Real ^ ¹ process virtual machine according to claim 2, wherein characterized in that it comprises a.

7. The execution method of a virtual machine according to claim 2, wherein the step of rewriting to the second special instruction is performed at the time of execution instead of at the time of loading the intermediate code.

8. An execution device of a virtual machine for executing intermediate code,

C P U that runs native code,

A memory for storing intermediate code,

Means for loading an intermediate code on the memory;

Virtual machine means on the CPU for interpreting and executing the intermediate code, and a loop portion repeatedly executed when the intermediate code is executed by the virtual machine means, dynamically detecting during the execution, Means for converting the intermediate code of the loop portion into native code,

For the loop portion of the intermediate code, the native code is

An execution device of a virtual machine, which is directly executed by CPU.

9. A recording medium storing a computer program for executing a virtual machine for executing an intermediate code,

Loading the intermediate code on a memory that stores the intermediate code; and interpreting and executing the intermediate code by a virtual machine on a CPU. Dynamically detecting a loop portion repeatedly executed during execution of the code during the execution, and converting intermediate code of the loop portion into native code;

Directly executing the native code by the CPU for the loop portion of the intermediate code;

A recording medium storing a computer program comprising: