JP2002073345A - Information processing system and storage medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To execute a program for a virtual machine faster. SOLUTION: The program loader 16 reads out a byte code from the cluster file 12, decides whether a load location of this byte code and an argument setup byte code is the Java virtual machine 13 or the JIT compiler 15 based on content of a determination information storage unit 17 if the byte code is a subroutine call and iterates a loading process for the byte code to the decided load location. If the byte code is not the subroutine call, the loading location is decided to Java virtual machine 13. The content of determination information storage unit 17 is decided by the static analyzer 18 to analyze the content of the cluster file 16 or a person before the cluster file 12 is executed.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an information processing apparatus in which a virtual machine interprets and executes a virtual machine instruction code on an OS platform, and a JIT compiler dynamically compiles and executes the virtual machine instruction code. The present invention relates to a computer-readable recording medium on which a program to be executed is recorded.

[0002]

2. Description of the Related Art FIG. 7 is a schematic software block diagram showing a Java (registered trademark) program execution environment.

[0003] A Java source file 10 containing a program and data is converted by a Java compiler 11 into a class file 12 containing a bytecode sequence and data. The bytecode is JVM (Java Virtual Machin
e) interpreted and executed by 13; JVM13 is W
running on Windows (R) 14.
Various subroutines of the windows 14 can be used. By providing the JVM 13, there is an advantage that a bytecode independent of a machine can be executed, but there is a problem that overhead is large.

In order to solve this problem, Windows
It has a JIT (Just-In-Time) compiler 15 operating on s14 and converts the bytecode of the class file 12 into JI
When compiled by the T compiler 15 at the time of execution, that is, dynamically compiled, the result is stored, and when this byte code (virtual machine code) is executed for the second time or later, the native language compiled without compiling again is used. A method of executing code (native machine code) is used.

[0005]

However, depending on the contents of the class file 12, the JIT compiler 15
There is a case where the processing performed by is slower than the processing performed by the JVM 13. This point is based on the Java platform on OS other than Windows14 (Java compiler 11,
JVM 13 and JIT compiler 15 are Windows
It constitutes a Java platform operating on s14. The same applies to the Java program that operates in ()), and also to other virtual machine programs such as Smalltalk.

SUMMARY OF THE INVENTION In view of the above problems, an object of the present invention is to provide an information processing apparatus capable of executing a program of a virtual machine at a higher speed and a computer-readable recording medium on which a program for executing the processing is recorded. Is to provide.

[0007]

According to the present invention, in an information processing apparatus in which a virtual machine interprets and executes a virtual machine instruction code on an OS platform, a program storage unit in which a virtual machine instruction code string is stored. A judgment information storage unit for storing judgment information, a storage unit in which a JIT compiler for compiling and executing the loaded virtual machine instruction code is installed, and a virtual machine instruction code is read from the program storage unit. Based on the determination information, it is determined whether to load the virtual machine instruction code into the virtual machine or into the JIT compiler, and the process of loading the virtual machine instruction code into the determined load destination is repeatedly executed. A storage unit in which a program loader is installed.

According to this information processing apparatus, every time one or more virtual machine instruction codes are read out, they are executed by the virtual machine or the JIT compiler according to the contents of the judgment information. The processing time is reduced as compared with the case of executing the virtual machine instruction code.

[0009] Other objects, configurations and effects of the present invention will become apparent from the following description.

[0010]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of the present invention will be described below with reference to the drawings.

FIG. 1 is a schematic software block diagram showing a Java program execution environment according to an embodiment of the present invention.

This software is installed in an information processing device such as a computer or a mobile phone.

In the present embodiment, the byte code of the class file 12 is interpreted and executed by the JVM 13 or dynamically compiled and executed by the JIT compiler 15 in accordance with the contents thereof, thereby repeatedly executing the JVM 13
It is faster than when only the JIT compiler 15 or the JIT compiler 15 is used.

Whether to load the bytecode to the JVM 13 or the JIT compiler 15 is determined by the program loader 16 based on the contents of the determination information storage unit 17. Before executing the class file 12, the contents of the determination information storage unit 17 are determined by a static analyzer 18 or a person (a program developer or a system operator) that analyzes the contents of the class file 12.

FIG. 2 is a schematic flowchart showing the procedure for executing the class file 12 of FIG.

(S1) The program loader 16 reads the next byte code from the class file 12.

(S2) If this code is an end code, the program loader 16 ends the processing, otherwise proceeds to the next step S3.

(S3) If this byte code is not a subroutine call, the process proceeds to step S4. If this byte code is a subroutine call, the program loader 1
6 reads a byte code group (a subroutine called with the current byte code) related thereto from the class file 12 from the class file 12, and the byte code group has been compiled by the JIT compiler 15 in the past, and the result is stored in the memory. If stored in step S7
Otherwise, the process proceeds to step S4.

(S4) If the bytecode read in step S1 is not a subroutine call, the flow advances to step S5. If the bytecode is a subroutine call, the program loader 16 refers to the contents of the determination information storage unit 17 and determines whether to compile the bytecode group as described later. When it is determined not to compile, the process proceeds to step S5, and when it is determined that the compile is not performed, the process proceeds to step S6.

(S5) The program loader 16 loads the bytecode into the JVM 13. The JVM 13 interprets this bytecode and converts the obtained native code into M
Supply to PU and execute. Next, the process returns to step S1.

(S6) The program loader 16 loads the byte code group into the JIT compiler 15. JIT
The compiler 15 compiles (converts the byte code group) into a native code.

(S7) The JIT compiler 15 supplies the converted native code to the MPU for execution. Next, the process returns to step S1.

In FIG. 1, both the JVM 13 and the JIT compiler 15 operate on Windows 14,
This can be used by calling a subroutine that Windows 14 has.

FIG. 3 shows a case where the graphics drawing library of Windows 14 is called while the bytecode of the class file 12 is being executed, and the device driver is further read during the execution. In such processing, since the processing time in the graphic drawing library and the device driver is relatively long, the byte code group for calling the graphic drawing library is almost the same whether executed by the JVM 13 or the JIT compiler 15. In this case, when executed by the JIT compiler 15,
Since it is necessary to store the compiled native code sequence, the program loader 16 loads this bytecode group into the JVM 13.

FIGS. 4A and 4B both show a comparison of the processing times when a certain bytecode group is repeatedly executed by the JVM 13 and when it is repeatedly executed by the JIT compiler 15.

When executed by the JVM 13, the processing time t 1 is the same every time. However, when executed by the JIT compiler 15, if the bytecode group is compiled once,
Since the compilation is omitted after the first time, the processing time t3 after the second time is shorter than the first processing time (t2 + t3) by the compilation time t2. Note that the time t3 also includes an overhead.

In FIG. 4A, a certain byte code group is set to 1
When the execution is performed only once, the use of the JVM 13 is faster, but when the byte code group is executed twice, the result is almost the same regardless of whether the JVM 13 or the JIT compiler 15 is used. Is executed three or more times, the use of the JIT compiler 15 can reduce the processing time. FIG.
In (B), when a certain bytecode group is executed only once, the time becomes almost the same regardless of whether the JVM 13 or the JIT compiler 15 is used. However, when this bytecode group is executed twice or more, This shows that the processing time can be reduced by using the JIT compiler 15.

Such analysis is performed by the static analyzer 18 of FIG. 1 or a person, and information to be stored in the determination information storage unit 17 is determined.

FIG. 5 is an explanatory diagram showing a specific example of the contents of the judgment information storage unit 17 and the parts related thereto.

The subroutine call bytecodes BCα to BCδ (excluding bytecodes for setting arguments) which may be executed by the JIT compiler 15 are previously stored in the determination information storage unit 17 as reference bytecodes. ing. Information of a flag F, a comparison value N, and a count k described below is added to each reference bytecode.
The flag F and the comparison value N are, like the reference bytecode,
Determined by static analyzer 18 or a person.

FIG. 6 is a flowchart showing the processing of the program loader 16 of FIG. 5 for one subroutine call bytecode BCi read from the class file 12.

(S9) The count k corresponding to each reference byte code in the judgment information storage unit 17 is cleared to zero.

(S10) The byte code BCi is compared with the next reference code in the judgment information storage unit 17. First, the byte code BCi is compared with the reference code BCα.

(S11) If there is no next reference bytecode in the judgment information storage unit 17, the process proceeds to step S12, and if not, the process proceeds to step S13.

(S12) Byte code BCi is converted to JVM1
3 and the process ends.

(S13) If the comparison results match, the process proceeds to step S14; otherwise, the process returns to step S10.

(S14) If F = '0', step S
The process advances to step S15, and if F = '1', the process advances to step S18.

(S15) The count k is incremented by one.

(S16) If N <k, step S10
The process returns to step S17 if N = k.

(S17) The flag F is set to "1".

(S18) A bytecode related to the bytecode BCi is read from the class file 12, and a bytecode group composed of the bytecode BCi and the bytecode BCi is read by the JI.
Load into the T compiler 15.

By such processing, the byte code BC
When i and the reference bytecode of F = '1' match, the byte code group including the bytecode BCi is executed by the JIT compiler 15, and the bytecodes BCi and F =
If the reference bytecode of “0” matches, when this bytecode BCi appears N times or more, the bytecode group including the bytecode BCi is changed to the JIT compiler 15.
Executed in For example, in the case of FIG.
'1', N = 2, and when the bytecode BCi appears more than once, it is predicted to appear more than three times,
The byte code group including the byte code BCi is executed by the JIT compiler 15. In the case of FIG.
If the bytecode BCi appears, the bytecode group including the bytecode BCi is always executed by the JIT compiler 15.

According to the present embodiment, since the bytecode is executed by the JVM 13 or the JIT compiler 15 according to the contents as described above, only the JVM 13 or the JIT
The processing time is shorter than when the bytecode is executed only by the compiler 15.

The present invention also includes various modifications.

For example, the first time and the second time t when the byte code group is executed by the JIT compiler 15
2 and t3 are stored in the determination information storage unit 17 in advance, and
During the execution of the class file 12, when this bytecode group first appears, the program loader 16 loads the bytecode group into the JVM 13, measures its execution time t1, stores it in the determination information storage unit 17, and stores it in t1 to t1. The comparison value N may be determined based on the value of t3.

In FIG. 5, without using the flag F, the comparison value N and the count k are used, the initial value of k is set to 0, and F =
The value of N corresponding to '1' is set to 1 and the byte code BCi
When k is equal to the reference bytecode, k may be incremented by 1 and the bytecode group may be loaded into the JIT compiler 15 when k = N. Also, k
Is set to N, the value of N corresponding to F = '1' is set to 1, k is decremented by 1 when the byte code BCi matches the reference byte code, and when k = 0, the byte code group May be loaded into the JIT compiler 15.

The present invention is also applied to virtual machines other than the Java language. The virtual machine may operate on an OS other than Windows14.

[Brief description of the drawings]

FIG. 1 is a schematic software block diagram showing a Java program execution environment according to an embodiment of the present invention.

FIG. 2 is a schematic flowchart showing an execution procedure of a class file of FIG. 1;

FIG. 3 shows that Wi is executed while executing bytecode of a class file.
FIG. 11 is an explanatory diagram showing a case where an nwindows graphic drawing library is called and a device driver is further read during execution thereof.

FIGS. 4A and 4B are diagrams showing a comparison of processing times when a certain bytecode group is repeatedly executed by a JVM and when a bytecode group is repeatedly executed by a JIT compiler.

FIG. 5 is an explanatory diagram showing a specific example of contents of a determination information storage unit in FIG. 1 and a part related thereto.

FIG. 6 is a flowchart showing a process of the program loader of FIG. 5 for one subroutine call bytecode BCi read from a class file.

FIG. 7 is a schematic software block diagram showing a conventional Java program execution environment.

[Explanation of symbols]

 Reference Signs List 10 Java source program 11 Java compiler 12 Class file 13 JVM 14 Windows 15 JIT compiler 16 Program loader 17 Judgment information 18 Static analyzer F flag N Comparison value k count BCi byte code

Claims (5)

[Claims] 1. An information processing apparatus in which a virtual machine interprets and executes a virtual machine instruction code on an OS platform, a program storage unit for storing a virtual machine instruction code sequence, and a determination information storage unit for storing determination information. A storage unit in which a JIT compiler that compiles and executes the loaded virtual machine instruction code is installed; reads a virtual machine instruction code from the program storage unit; and loads the virtual machine instruction code based on the determination information. A storage unit in which a program loader that determines whether to use the virtual machine or the JIT compiler and loads the virtual machine instruction code into the determined load destination repeatedly is installed. An information processing apparatus characterized by the above-mentioned. 2. The method according to claim 1, wherein the determination information has a reference instruction code, and is stored in the determination information storage unit before the program loader operates. The program loader reads the virtual machine from the program storage unit. If it is determined that the instruction code matches the reference instruction code, the virtual machine instruction code
2. The information processing apparatus according to claim 1, wherein the information is loaded into an IT compiler. 3. The determination information further includes a comparison value and a count. If the program loader determines that the virtual machine instruction code read from the program storage unit matches the reference instruction code, the program loader counts the count. 3. The information processing apparatus according to claim 2, wherein the load destination of the virtual machine instruction code is determined based on a comparison result between the count and the comparison value. 4. Before the program loader operates,
The information processing apparatus according to claim 2, further comprising: a storage unit in which a static analyzer that analyzes the virtual machine instruction code sequence and determines the reference instruction code is installed. 5. A method for reading a virtual machine instruction code and loading the virtual machine instruction code to a virtual machine that interprets and executes the virtual machine instruction code on an OS platform based on the determination information, A program loader that repeatedly determines whether or not to use a JIT compiler that dynamically compiles and executes on the OS platform and loads the virtual machine instruction code to the determined load destination is recorded. Characteristic computer readable recording medium.