JP2004078751A - Reuse method of compiled program code, system, and program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To maintain compiled optimum program codes obtained by execution of an application program for a long time even at restart of the application program. <P>SOLUTION: A user interface section 11 directs a file operation controller 12 to store compiled program codes together with a filename specified at starting time. A file conversion section 13 acquires dynamically compiled program codes 22, convert them into a format which can be saved as a file. The file conversion section 13 also acquires a class version UID (unique ID), and a version of a current virtual instruction code execution environment 10 from an executive program class file 23, and a version management section 14 respectively, and imparts them to the converted compiled program code 22. The file operation controller 12 stores the acquired compiled program code 22 by the directed filename at a file system 20. <P>COPYRIGHT: (C)2004,JPO

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention provides a virtual instruction implementing a dynamic compiler that dynamically optimizes a virtual instruction code and converts it into a real machine instruction code based on dynamic data (profile) at the time of program execution while executing the program. The present invention relates to a method, an apparatus, and a program for reusing a compiled program code in a code execution environment.
[0002]
[Prior art]
Virtual instruction code execution implemented with a conventional dynamic compiler that dynamically optimizes virtual instruction codes and converts them to real machine instruction codes based on dynamic data (profile) during program execution while executing the program In the environment, the compiled program code compiled by the dynamic compiler obtained by executing the application program is inherited even if the above-mentioned virtual instruction code execution environment is restarted to execute the same application program. Not.
[0003]
[Problems to be solved by the invention]
Therefore, the initial execution speed of the restarted application program may be significantly slower than the optimized execution speed in a long-running application program.
[0004]
For this reason, it is necessary to run the application program for as long as possible without restarting it, and to maintain the optimal execution speed. Will be restarted. In addition, the server-based program has a greater number of users than in normal operation immediately after recovery when service cannot be used due to a program failure or the like, and is a part that originally requires high-speed execution of application programs.
[0005]
As described above, in the related art, there is a problem that the execution speed of the application program immediately after startup is low.
[0006]
An object of the present invention is to provide a method, an apparatus, and a program for reusing a compiled program code that maintain an optimal compiled program code obtained by executing an application program for a long time even when the application program is restarted. is there.
[0007]
[Means for Solving the Problems]
The present invention converts a compiled program code used in a virtual instruction code execution environment into a format that can be stored as an external file, saves the file as a file in a file system, and starts the virtual instruction code execution environment. Sometimes, a specified external file is read out and restored to a state where it can be used as compiled program code by a dynamic compiler.
[0008]
Here, the compiled program code is a real machine instruction code dynamically compiled from a virtual instruction code at the time of execution by a runtime compilation.
[0009]
A virtual instruction code execution environment that implements a dynamic compiler that dynamically optimizes virtual instruction codes and converts them into real machine instruction codes based on dynamic data (profiles) during program execution while executing the program. Converts virtual instruction codes into real machine instruction codes and saves and reuses the compiled program code to execute the application program at high speed under the application program immediately before restarting even immediately after restarting the application program The same high-speed program execution speed can be maintained.
[0010]
BEST MODE FOR CARRYING OUT THE INVENTION
Next, embodiments of the present invention will be described with reference to the drawings.
[0011]
FIG. 1 is a configuration diagram of a virtual instruction execution environment 10 and a file system 20 including a dynamic compilation result reuse device according to an embodiment of the present invention.
[0012]
The dynamic compilation result reuse device includes a user interface unit 11, a file operation control unit 12, a file conversion unit 13, a version management unit 14, and a consistency verification unit 15.
[0013]
The user interface unit 11 issues an instruction to save the compiled program code together with the file specified by the user when the virtual instruction code execution environment 10 is started to the file operation control unit 12, and outputs the compiled program code together with the file name specified by the user. Is issued to the file operation control unit 12. The file operation control unit 12 receives the instruction to save the compiled program code, acquires the dynamically compiled program code 22 converted from the file conversion unit 13 into a format that can be saved as a file, and obtains the file system under the designated file name. Save to 20. Further, when receiving the instruction to read the compiled program code, the file operation control unit 12 reads the file having the specified file name from the file system 20 and notifies the file conversion unit 13 of the file. The file conversion unit 13 extracts a version number from the content of the notified file, notifies the version management unit 14, determines the version check result returned from the version management unit 14, and determines that there is no compatibility. An error is notified to the user interface unit 11, and if the version check is normal, the contents read from the file are converted into a compiled program code in an internal data format and copied as a dynamically compiled program code 22 on the virtual memory. I do. The version management unit 14 determines whether the version number notified from the file conversion unit 13 is a compatible compiled program code, and returns a check result to the file conversion unit 13. The consistency verification unit 15 converts all the compiled program codes 22 into the executable program class file 23 in order to check the consistency between the compiled program code 22 converted by the file conversion unit 13 and the application program to be executed. Is checked, and the check result is returned to the file conversion unit 13.
[0014]
FIG. 2 shows a process of storing the compiled program code in the present embodiment. FIG. 3 shows a file storage format. The processing flow will be described below.
[0015]
Step 1. The user interface unit 11 that has detected a user instruction by key input (Ctrl + ￥) or the like instructs the file operation control unit 12 to save the compiled program code together with the file name specified at the time of startup.
[0016]
Step 2. Upon receiving the instruction, the file operation control unit 12 obtains the compiled program code 22 converted from the file conversion unit 13 into a format (byte array) that can be stored as a file.
[0017]
Step 3. The file conversion unit 13
(3-1) Obtain the dynamically compiled program code 22 in the virtual instruction code execution environment 10 and convert it into a format (byte array) that can be saved as a file. Also,
(3-2) The class version UID is obtained from the execution program class file 23 in the virtual instruction code execution environment 10.
(3-3) Obtain the version of the current virtual instruction code execution environment 10 from the version management unit 14 and add it to the converted compiled program code. The class version UID (Unique ID) is generated when the class file is created, and when a change occurs in the class file, another UID must be given. The UID generation algorithm may be a hash code for the entire contents of the class file, or may be time information when the class file is created from the source file.
[0018]
In step 2, the file operation control unit 12 acquires the converted compiled program code 22 to which the above information has been added.
[0019]
Step 4. The file operation control unit 12 stores the acquired compiled program code 22 in the file system 20 in the format shown in FIG.
[0020]
FIG. 4 shows a process of reading the file 21 storing the compiled program code according to the present embodiment. FIGS. 5 to 8 show error routes of the respective processes. The processing flow will be described below.
[0021]
Step 1. When the virtual instruction code execution environment is activated, it instructs the file operation control unit 12 to read out the compiled program code together with the file name specified as a parameter via the user interface unit 11.
[0022]
Step 2. Upon receiving the instruction, the file operation control unit 12 reads a file having the specified file name from the file system 20. If a file with the specified file name does not exist, that fact is notified to the user interface unit 11 (FIG. 5).
[0023]
Step 3. If the specified file exists, the file operation control unit 12 notifies the file conversion unit 13 of the read content.
[0024]
Step 4. The file conversion unit 13 extracts the version number from the file contents and notifies the version management unit 14 of the version number.
[0025]
Step5. The version management unit 14 checks whether the notified version number is a compatible compiled program code, and returns a check result to the file conversion unit 13.
[0026]
Step 6. The file conversion unit 13 determines the result of the version check, and if it is determined that there is no compatibility, notifies the user interface unit 11 of an error (FIG. 6).
[0027]
Step 7. If the version check is normal, the file conversion unit 13 converts the content (byte array) read from the file into a compiled program code in an internal data format and copies it as a dynamically compiled program code 22 on the virtual memory. . If the content cannot be converted, an error is notified to the user interface unit 11 (FIG. 7).
[0028]
Step 8. When the conversion into the internal data format of the compiled program code 22 is completed, the file conversion unit 13 checks the consistency of the converted compiled program code 22 with the application program to be executed. Instruct the verification unit 15.
[0029]
Step 9. Upon receiving the verification request, the consistency verification unit 15 checks whether the contents of all the compiled program codes 22 match the execution program class file 23. Also, the check result is returned to the file conversion unit 13 of the activation source.
[0030]
Step 10. The file conversion unit 13 determines the result of the consistency verification, and if the consistency is unacceptable, notifies the user interface unit 11 of an error to that effect (FIG. 8). If the consistency is OK, the control is returned to the user interface unit 11 upon normal termination.
[0031]
FIG. 9 shows a process for verifying the consistency between the compiled program code and the application program to be executed.
[0032]
The consistency verification unit 15 verifies that the application program that was being executed when the compiled program code was saved is exactly the same as when the compiled program code 22 was read. The data used for the verification is a class version UID assigned to each class.
[0033]
The procedure for verifying the integrity of the compiled program code is simple: identifying the class file being loaded from the class name in the read compiled program code 22, and determining whether both class version UIDs match. , Only for all class version UIDs.
[0034]
In addition to the method of reusing the compiled program code described above, in addition to the method realized by dedicated hardware, a program for realizing the function is recorded on a computer-readable recording medium, and the recording medium is stored in the recording medium. The recorded program may be read by a computer system and executed. The computer-readable recording medium refers to a recording medium such as a floppy disk, a magneto-optical disk, a CD-ROM, or a storage device such as a hard disk device built in a computer system. Further, the computer-readable recording medium is one that dynamically holds the program for a short time (transmission medium or transmission wave), such as a case where the program is transmitted via the Internet, and serves as a server in that case. It also includes those that hold programs for a certain period of time, such as volatile memory inside a computer system.
[0035]
【The invention's effect】
As described above, according to the present invention, optimization of a virtual instruction code and conversion to a real machine instruction code are dynamically performed while executing a program, based on dynamic data (profile) at the time of program execution. In order to execute an application program at high speed under a virtual instruction code execution environment in which a dynamic compiler is implemented, convert the virtual instruction code into a real machine instruction code, and save and reuse the compiled program code to be compiled. Accordingly, a high program execution speed can be maintained even after the restart of the application program, which is the same as before the restart.
[Brief description of the drawings]
FIG. 1 is a configuration diagram of a virtual instruction execution environment and a file system according to an embodiment of the present invention.
FIG. 2 is a diagram illustrating a process of storing a dynamically compiled program code;
FIG. 3 is a diagram showing a file storage format.
FIG. 4 is a diagram showing a process of reading a dynamically compiled program code.
FIG. 5 is a diagram showing an error route of a designated file error.
FIG. 6 is a diagram showing an error route of a version check error.
FIG. 7 is a diagram showing an error route for invalid file contents.
FIG. 8 is a diagram showing an error route of an integrity verification error.
FIG. 9 is an explanatory diagram of a consistency verification method.
[Explanation of symbols]
Reference Signs List 10 virtual instruction execution environment 11 user interface unit 12 file operation control unit 13 file conversion unit 14 version management unit 15 consistency verification unit 20 file system 21 dynamically compiled program code storage file 22 dynamically compiled program code 23 execution program class File

Claims (9)

In a virtual instruction code execution environment that implements a compiler that dynamically optimizes a virtual instruction code and converts it into a real machine instruction code based on dynamic data during program execution while executing the program,
A method for reusing a compiled program code in which a compiled program code optimized by dynamic compilation is stored in an external file, and when the virtual instruction code execution environment is started, the stored external file is read and a compilation result is reused. . 2. The method for reusing a compiled program code according to claim 1, wherein the file format of the external file storing the compiled program code and the content of the file read out at the time of starting the virtual instruction code execution environment are verified. . 3. The compiled instruction according to claim 1 or 2, wherein verification of consistency between the content of the external file in which the compiled program code is stored and read out at the time of starting the virtual instruction code execution environment and the application program to be executed is performed. How to reuse program code. The compiled program according to any one of claims 1 to 3, wherein the compatibility of the version of the external file storing the compiled program code with the version of the virtual instruction code execution environment from which the external file is read is verified. Code reuse method. In a virtual instruction code execution environment implementing a dynamic compiler that dynamically optimizes a virtual instruction code based on dynamic data at the time of program execution and converts it into a real machine instruction code while executing the program,
Means for obtaining a dynamically compiled program code in the virtual instruction execution environment and converting the program code into a format storable as a file;
Means for storing the converted compiled program code in an external file with a specified file name, and for reading a file with a specified file name from the external file;
An apparatus for reusing a compiled program code, comprising: means for converting a file read from the external file into a compiled program code in an internal data format and copying it as a dynamically compiled program code on a virtual memory. 6. The compiled program code according to claim 5, further comprising means for verifying whether the file format and the contents of the external file in which the compiled program code is stored and read out at the time of starting the virtual instruction code execution environment are valid. Recycling device. 7. The apparatus according to claim 5, further comprising means for verifying the consistency between the content of the external file in which the compiled program code is read and read at the time of starting the virtual instruction code execution environment and the application program to be executed. Compiled program code reuse device. The compile according to any one of claims 5 to 7, further comprising means for verifying compatibility between a version of the external file storing the compiled program code and a version of the virtual instruction code execution environment from which the external file is read. Used program code reuse device. A program for causing a computer to execute the compiled program code reuse method according to any one of claims 1 to 4.

Images