JP2003202995A - Intermediate code preprocessing apparatus, intermediate code execution system, intermediate code preprocessing program and intermediate code execution program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide an intermediate code execution system, etc., for fast processing an intermediate code. <P>SOLUTION: This intermediate code execution system has a first subsystem 308 having a first interpreter 309 which corresponds to an instruction set generated during compilation and sequentially interprets and executes instructions included in an intermediate code, a second subsystem 310 having a preprocessing section 311 which applies to the intermediate code preprocessing to substitute an instruction pattern consisting of a plurality of instructions of with an alternative instruction, and a second interpreter 312 which corresponds to an instruction set including the alternative instruction and sequentially interprets and executes an instruction code included in the preprocessed intermediate code, and a method analysis section 308 which selects either processing to execute the intermediate code by the first interpreter or processing to apply preprocessing to the intermediate code by the preprocessing section and then executes the intermediate code by the second interpreter 312. <P>COPYRIGHT: (C)2003,JPO

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an intermediate code preprocessing device for preprocessing intermediate code, an intermediate code execution system for executing intermediate code, and computer programs thereof.

[0002]

2. Description of the Related Art For the purpose of providing a program that does not depend on a computer platform such as hardware or OS, a virtual machine (VM) is created on each platform by a software method or a hardware method. A method of constructing and executing intermediate code between source code and object code (hereinafter referred to as intermediate code) on this virtual machine has been proposed. As one of the programming languages adopting such a method, there is Java (R) which adopts an intermediate code format called a class file.
In the following, the hardware and the virtual machine constructed on the hardware may be collectively referred to as an intermediate code execution system.

According to the above method, since a single program code can be supplied to various platforms and executed, it is not necessary to prepare an object code that can be executed only on each platform. As a result, not only can the distribution of the program be simplified, but also the software development can be made efficient. Therefore, virtual machines are being constructed on various computer platforms. Furthermore, recently, in various electronic devices (hereinafter referred to as embedded devices) equipped with a processor, a virtual computer is starting to be built on the processor.

Here, as a virtual computer, an interpreter system is known which is constructed on a platform by software and sequentially interprets and executes bytecode instructions contained in a class file.

However, the interpreter type virtual machine requires a process of extracting each bytecode instruction from the class file and interpreting its contents, and this process may become an overhead of the system. . To reduce such overhead and improve performance, a JIT compiler (Just In Time C) that compiles class files into native code specific to each hardware and then executes them.
ompiler) method and AOT compiler (Ahead Of Time C)
ompiler) method has been proposed. Further, it has been attempted to construct a virtual machine in hardware, such as a Java (R) chip specially designed to directly execute bytecode instructions.

Since the compiler system such as JIT or AOT described above executes the native code of the processor, it is superior to the interpreter system only in terms of instruction execution speed. However, in the compiler method, the work memory necessary for the compilation work itself,
There is a problem in that a larger amount of memory is required than in the interpreter method because an area for storing a native code that is 4 to 10 times larger than the class file is required.

[0007] Such a problem becomes remarkable especially in an embedded device in which hardware resources are more restricted than in an ordinary computer. In addition, when starting the compilation after instructing the execution of the class file, there is a possibility that the compilation work becomes an overhead and sufficient performance cannot be obtained.

According to the above Java (R) chip, it is possible to execute a class file with high performance without compiling. However, a large amount of development cost is required for developing such a dedicated chip. That is, the cost of the chip itself cannot be avoided. Further, in view of the fact that the version of the language specification is appropriately upgraded or modified according to technological progress and market needs, it is not always preferable to configure the virtual machine as hardware. In particular, for virtual machines in embedded devices, due to the strong demand for cost reduction and the specification upgrade in a short cycle, Java
The adoption of (R) chips is not practical.

As described above, the compiler method and J
The technology of the ava (R) chip and the like has problems in terms of cost, required hardware resources, etc., and it is particularly difficult to apply them to embedded devices with severe restrictions. Therefore, it is desired to improve the performance of the virtual machine or the intermediate code execution system by another method in view of the application to the embedded device.

[0010]

SUMMARY OF THE INVENTION The present invention has been made in view of the above circumstances, and an intermediate code preprocessing device capable of improving the performance during execution of intermediate code by performing preprocessing. It is an object of the present invention to provide an intermediate code execution system incorporating preprocessing and these programs.

[0011]

In order to solve the above problems, according to a first aspect of the present invention, an intermediate code obtained by compiling a source code created in a predetermined programming language is preprocessed. In the intermediate code preprocessor,
A storage unit that stores the intermediate code, and a processing unit that replaces a specific instruction pattern including a plurality of instructions included in the intermediate code stored in the storage unit with an alternative instruction that is associated with the specific instruction pattern in advance. An intermediate code preprocessor is provided which comprises:

According to an eighth aspect of the present invention, there is provided an intermediate code preprocessing program for preprocessing an intermediate code obtained by compiling a source code created in a predetermined programming language, wherein the processing means includes: There is provided an intermediate code preprocessing program characterized by executing a process of replacing a specific instruction pattern included in the intermediate code with an alternative instruction previously associated with the specific instruction pattern.

According to the first and second aspects of the present invention,
Since a specific instruction pattern composed of a plurality of instructions included in the intermediate code is replaced with an alternative instruction that is associated with the instruction pattern in advance, it is possible to reduce the number of instructions to be processed when executing the intermediate code, and Since it is possible to omit redundant processing between instructions in a specific instruction pattern, it is possible to improve performance during execution of intermediate code by performing such preprocessing. Moreover,
In this preprocessing, the size of the intermediate code does not increase, and the preprocessing itself is a simple replacement process, so that it can be executed with low overhead.

According to a third aspect of the present invention, there is provided an intermediate code execution system for executing an intermediate code obtained by compiling a source code created in a predetermined programming language, and storing means for storing the intermediate code. And a processing unit, wherein the processing unit a) substitutes a specific command pattern composed of a plurality of commands included in the intermediate code stored in the storage unit in advance with the specific command pattern. A process of substituting with an instruction, and b) in sequentially interpreting and executing the intermediate code in which the specific instruction pattern is replaced with the alternative instruction, the alternative instruction is substantially equivalent to the specific instruction pattern. There is provided an intermediate code execution system characterized by executing a process that is interpreted and executed.

According to a fourth aspect of the present invention, an intermediate code execution program for executing an intermediate code obtained by compiling a source code created in a predetermined programming language, wherein the processing means includes: a) intermediate code A process of replacing a specific instruction pattern composed of a plurality of instructions included in the above with an alternative instruction previously associated with the specific instruction pattern; and b) an intermediate code in which the specific instruction pattern is replaced with the alternative instruction. In interpreting and executing, an intermediate code execution program is provided, which executes a process of interpreting and executing the alternative command into a process substantially equivalent to the specific command pattern.

According to the third and fourth aspects of the present invention,
Preprocessing is performed by replacing a specific instruction pattern consisting of multiple instructions included in the intermediate code with an alternative instruction, and the preprocessing is performed while interpreting the alternative instruction as a process substantially equivalent to the instruction pattern before replacement. Since the intermediate code is sequentially interpreted and executed, the intermediate code can be executed while reducing the number of instructions of the intermediate code and omitting redundant processing between instructions in a specific instruction pattern. You can improve performance when code is executed.

According to a fifth aspect of the present invention, in an intermediate code execution system for executing an intermediate code obtained by compiling a source code created in a predetermined programming language, a plurality of intermediate codes executing the intermediate code. An executing unit, a storing unit that stores the intermediate code, stores a correspondence relationship between an instruction included in the intermediate code and the intermediate code executing unit suitable for efficient execution of the instruction, and an intermediate code analyzing unit. The intermediate code analyzing unit includes: a) a process of specifying an instruction included in the intermediate code stored in the storage unit; and b) the intermediate code based on the specified command and the correspondence relationship. A process for identifying an intermediate code execution means suitable for efficient execution of
An intermediate code execution system is provided, which executes a process of recording a relationship between the intermediate code and the specified intermediate code execution means.

According to a fifth aspect of the present invention, the intermediate code execution system is provided with a plurality of intermediate code execution means, and the instructions included in the intermediate code correspond to the intermediate code execution means suitable for efficient execution thereof. The relationship is stored in the storage means, the intermediate code analysis means analyzes the intermediate code, and the intermediate code execution means suitable for efficient execution of the intermediate code is specified based on the correspondence relationship stored in the storage means. The intermediate code execution system can identify the optimum intermediate code execution means for each intermediate code. Therefore, it becomes possible to execute the intermediate code by using the intermediate code executing means suitable for the intermediate code to be executed, and by utilizing each of the plurality of intermediate code executing means, the performance at the time of executing the intermediate code can be improved. Can be improved.

In a fifth aspect of the present invention, the correspondence between the instruction in the storage means and the intermediate code execution means suitable for efficient execution of the instruction is such that each instruction is executed by each of the intermediate code execution means. And a processing efficiency score table, and b) the processing efficiency score when the specified instruction is executed by each of the intermediate code executing means based on the score table. And b3) a process of summing the acquired scores for each intermediate code execution unit, and b3) a process of summing the acquired scores for each intermediate code execution unit. It may be configured to include a process of specifying an executing unit.

The correspondence between the instruction in the storage means and the intermediate code executing means suitable for efficient execution of the instruction corresponds to the value of the point assigned to each instruction and the intermediate code executing means. And the range of the total value of the points, the process of b) includes b1) a process of acquiring the point of the specified instruction based on the correspondence, and b2) a total value of the acquired points. It may be configured to include a process for obtaining and b3) a process for identifying the intermediate code executing means used for executing the intermediate code based on the correspondence relationship and the obtained total value.

According to a sixth aspect of the present invention, a general intermediate code capable of executing all instructions in an intermediate code execution system for executing an intermediate code obtained by compiling a source code created in a predetermined programming language. The intermediate code analyzing means comprises an executing means, a special intermediate code executing means capable of executing only a part of instructions, a storing means in which the intermediate code is stored, and an intermediate code analyzing means.
A process of analyzing the intermediate code stored in the storage means, and determining whether the instruction included in the intermediate code includes an instruction that the special intermediate code execution means cannot execute;
b) When it is determined that the unexecutable instruction is not included, it is recorded that the intermediate code is to be executed by the special intermediate code executing means, and when it is determined that the unexecutable instruction is included, the intermediate There is provided an intermediate code execution system characterized by executing processing for recording that code should be executed by the general intermediate code execution means.

According to a sixth aspect of the present invention, an intermediate code execution system comprising general intermediate code execution means capable of executing all instructions and special intermediate code execution means capable of executing only some instructions. In, whether the general intermediate code executing means or the special intermediate code executing means should execute is recorded depending on whether or not the intermediate code to be executed includes an instruction executable by the special intermediate code executing means. .
Therefore, in the intermediate code execution system to which the special intermediate code execution means specialized only for some instructions is added, it becomes possible to use the general intermediate code execution means and the special intermediate code execution means properly. Time performance can be improved.

According to a seventh aspect of the present invention, in an intermediate code execution system for executing an intermediate code obtained by compiling a source code created in a predetermined programming language by an interpreter system, a memory storing the intermediate code. A preprocessing means for performing, on the intermediate code stored in the storage means, a process of replacing a specific instruction pattern included in the intermediate code with an alternative instruction previously associated with the specific instruction pattern; A first interpreter that cannot interpret and execute the alternative instruction; a second interpreter that can interpret and execute the alternative instruction with a content equivalent to the instruction pattern before replacement; and the preprocessing means. The processed intermediate code is analyzed to determine whether or not the intermediate code includes the alternative instruction, and the alternative instruction If included, record that the intermediate code should be executed by the first interpreter, and if the alternative instruction is not included, execute the intermediate code by the second interpreter. An intermediate code execution system is provided, which comprises:

According to a seventh aspect of the present invention, a preprocessing means for performing preprocessing for replacing a specific instruction pattern with an alternative instruction, a first interpreter corresponding to the alternative instruction, and an alternative instruction are provided. An intermediate code in which the intermediate code after the preprocessing is analyzed by the intermediate code analysis means and the specific instruction pattern is replaced by the alternative instruction in the preprocessing in the configuration including the second interpreter which does not exist and the intermediate code analysis means Records what should be executed by the first interpreter, and records what should be executed by the second interpreter for the intermediate code that has not been replaced even if preprocessing is performed. Therefore, the intermediate code can be executed with high performance by effectively utilizing the configuration including the preprocessing unit, the first interpreter, and the second interpreter.

According to an eighth aspect of the present invention, in an intermediate code execution system for executing an intermediate code obtained by compiling a source code created in a predetermined programming language by an interpreter method, the instructions generated by the compilation are A first subsystem having a first interpreter capable of interpreting and executing everything; a pre-processing unit for performing pre-processing for replacing an instruction pattern consisting of a plurality of instructions included in an intermediate code with an alternative instruction; A second subsystem having a second interpreter capable of interpreting and executing the alternative instruction with substantially the same content as the instruction code before replacement, and, depending on the intermediate code to be executed,
A process of executing the intermediate code by the first interpreter in the first subsystem, and a process of preprocessing the intermediate code by the preprocessing unit in the second subsystem and then executing the process by the second interpreter. An intermediate code execution system is provided, comprising: a selection unit that selects either one of processing and processing.

According to an eighth aspect of the present invention, a first subsystem having a normal interpreter, preprocessing means for replacing a specific instruction pattern with an alternative instruction, and preprocessing by the preprocessing means. The performance at the time of executing the intermediate code can be improved by properly using the second subsystem having the second interpreter specialized for executing the intermediate code according to the intermediate code to be executed.

According to an eighth aspect of the present invention, the second
The subsystem assigns an alternative instruction to the operation code to which the specific instruction is assigned in the first subsystem, and the selection unit determines whether the intermediate code to be executed includes the specific instruction. May select a process by the first subsystem, and select a process by the second subsystem when the intermediate code to be executed does not include the specific instruction.

A ninth aspect of the present invention is an intermediate code execution system for executing an intermediate code obtained by compiling a source code created in a predetermined programming language, the plurality of instructions included in the intermediate code. And a pre-processing unit that performs pre-processing for replacing the first instruction pattern with the first alternative instruction, and interprets and executes the first alternative instruction with substantially the same content as the instruction code before replacement. A first subsystem having a first interpreter capable of performing the preprocessing, a preprocessing unit that performs a preprocessing for replacing a second instruction pattern included in the intermediate code with a second alternative instruction, and the second subsystem.
A second subsystem having a second interpreter capable of interpreting and executing the alternative instruction of the above-described instruction code with substantially the same content as the instruction code before replacement, and the first subsystem according to the intermediate code to be executed. In the subsystem of executing the intermediate code by the first interpreter, and in the second subsystem of preprocessing the intermediate code by the preprocessor, and then executing the second interpreter. An intermediate code execution system is provided, which comprises: a selection unit that selects either one.

According to a ninth aspect of the present invention, there is provided preprocessing means for replacing a specific instruction pattern with an alternative instruction and an interpreter specialized for executing intermediate code preprocessed by the preprocessing means. In an intermediate code execution system having two systems for different instruction patterns and alternative instructions, the subsystem can be used properly according to the intermediate code that executes the two subsystems, thereby improving the performance during execution of the intermediate code. it can,

In a ninth aspect of the present invention, the first aspect
Subsystem assigns the first alternative instruction to a first opcode, the second subsystem assigns the second alternative instruction to a second opcode, and the selector executes When the intermediate code includes the instruction related to the first opcode, the process by the second subsystem is selected, and when the intermediate code to be executed includes the instruction related to the second opcode, the first code is selected. The processing by the subsystem can be selected.

In each of the above aspects, the "command pattern" is a series of predetermined commands. The “alternative instruction” means an instruction that is replaced with the instruction pattern, and is an original instruction that is expressed by a code shorter than the instruction pattern and that is executed in an execution environment corresponding to the alternative instruction.

[0030]

BEST MODE FOR CARRYING OUT THE INVENTION Embodiments of the present invention will be described below with reference to the drawings. [First Embodiment] First, with reference to FIGS. 1 to 4, an intermediate code preprocessing device according to a first embodiment of the present invention will be described in detail. FIG. 1 shows Java as an intermediate code.
1 shows a hardware configuration of an intermediate code preprocessing device 1 according to a first embodiment for preprocessing a (R) class file.

The intermediate code preprocessing device 1 includes a storage unit 1
01, a processing unit 102, and an input unit 103. The processing unit 102 is an arithmetic unit such as an MPU or a microcontroller. The number of processing units 102 is not limited to one, and may be a configuration that enables distributed processing by a plurality of MPUs and a plurality of types of arithmetic devices.

The input unit 103 inputs a class file or the like to the intermediate code preprocessing device 1. The class file input from the input unit 103 is stored in the storage unit 10.
It is stored in 1. The storage unit 101 is, for example, a RAM or RO.
It consists of a memory such as M. Here, for convenience of description, only one storage unit 101 is described, but a configuration in which a plurality of storage units are dispersedly arranged may be used.

In a predetermined area of the storage unit 101, an instruction pattern 101a composed of a plurality of instructions and an alternative instruction 101
A table associated with b is stored, and a class file 101c is also stored. Here, the instruction pattern 101a is a pattern composed of a plurality of bytecode instructions.

Hereinafter, a case where integers are added will be described as an example. In this case, the method included in the Java (R) class file may be, for example, FI.
G. As shown in 3, "iload", "iloa"
The command patterns "d" and "iadd" may frequently appear. Therefore, in the intermediate code preprocessing device 1 according to the first embodiment, such an instruction pattern that frequently appears is replaced with an alternative instruction such as “v
The table associated with “_v_iadd” is stored in the storage unit 101.
To store. Here, "iload" is a mnemonic notation of an intermediate code consisting of 2 bytes that pushes the value of the local variable onto the operand stack. “Iadd” is a mnemonic notation of a 1-byte intermediate code that pops two values from the operand stack, adds them, and pushes the result to the operand stack.

The alternative instruction 101b is the alternative instruction 101.
In an environment where b can be executed, the instruction pattern 10
It is an instruction that is interpreted in the same processing as 1a. In other words, the present embodiment is premised on the existence of an intermediate code execution system capable of interpreting and executing the alternative instruction 101b substantially equivalent to the instruction pattern before replacement. Such an intermediate code execution system may, for example, in the above case, replace the alternative instruction “v_v_iadd” with the above “ilo”.
It is interpreted and executed in the same process as the command patterns "ad", "iload", and "iadd". When executing such alternative instructions, prevent frequent access to memory,
It is desirable to minimize the overhead factor in executing instructions by omitting redundant processing and utilizing registers.

The code length of the alternative instruction 101b is shorter than that of the instruction pattern 101a. For example, the alternative instruction “v_v_iadd” has a code length of 3 bytes, which is shorter than the code length of 5 bytes before replacement.

Therefore, according to such pre-processing,
It is also possible to reduce the size of the class file 101c.

The present embodiment mainly corresponds to the invention described in claim 1 or 15, and the storage unit etc. 1
01 corresponds to the storage means in the present invention, and the processing unit 102 corresponds to the processing means.

In the above configuration, the processing section 102
By executing a series of software programs, each function of the intermediate code preprocessing device 1 is realized, and the class file 101c is preprocessed as described below.

FIG. 2 is a flow chart for explaining the procedure of preprocessing in this embodiment. Here, it is assumed that the class file 101c is input to the intermediate code preprocessing device 1 from the input unit 103 in advance and stored in the storage unit 101. Under this premise, processing is performed by the following procedure.

That is, first, when the intermediate code preprocessing is started (S101), the processing section 102 causes the storage section 101 to associate the instruction pattern 101a and the alternative instruction 1 with each other.
The table of 01b is read (S102). Next, the processing unit 102 searches the class file 101c and specifies the instruction pattern 101a (S103). That is, for example, as shown in FIGS. 3 and 4, “iload”,
A series of instruction patterns 1 for "iload" and "iadd"
01a is specified in the class file 101c. When the instruction pattern is specified in this way, the processing unit 102 determines the instruction pattern 101a in the specified class file 101c.
Is replaced with the alternative instruction 101b associated with the instruction pattern 101a (S104).

FIG. 4 is a diagram for specifically explaining an example of the processing in S104. In this example, “iload 8”, “ilo 8” included in the specified instruction pattern
First, "ad9" and "iadd" are "nop" and "no".
p ”and“ v_v_iadd8,9 ”(first
Stage). Here, "nop" is an instruction that does nothing. In this way, inserting a plurality of "nops" before "v_v_iadd 8, 9" does not change the size of the converted class file and does not change the jump destination of the conditional branch included in the class file. This is because. After performing the process of the first step, the process of deleting "nop" is performed while changing the jump destination of the conditional branch and the like (second step). This completes the process of S104.

As described above, the preprocessing of the intermediate code is completed (S105).

According to the intermediate code preprocessing device of the first embodiment, the length of the code to be executed is "iload", "iload", "i" by the series of processes described above.
From the total 5 byte code of "add", "v_v_iad"
It is shortened to one instruction of 3 bytes "d". Therefore, the number of instructions to be executed can be reduced, redundant processing between instructions can be omitted, and the size of the class file can be reduced.

The intermediate code thus obtained is
In the execution environment corresponding to the alternative instruction 101b such as “v_v_iadd”, by interpreting and executing the alternative instruction 101b as a processing that is equivalent to the instruction pattern 101a before replacement and minimizes an overhead factor such as memory access, high speed Can be run to. In addition, the preprocessing of the intermediate code as described above can be executed with low overhead because it is merely code replacement, and
Since the size of the class file is not increased unlike the case of compiling to native code, the performance of intermediate code execution can be significantly improved.

For example, when the first embodiment is applied to a built-in device such as a mobile phone, the built-in device is equipped with an execution environment capable of executing the above-mentioned alternative instruction 101b, and the intermediate code preprocessor 1 is used to perform The processed class file may be preinstalled or distributed to the embedded device. By doing so, the performance of the Java (R) application executed on the embedded device can be improved.

Further, the built-in equipment is equipped with an execution environment capable of executing the above-mentioned preprocessing device 1 and the alternative instruction 101b, and performs preprocessing of the class file and execution of the preprocessed class file on the mobile phone. Both may be performed.

In the first embodiment, the instruction pattern 1
Although a table in which 01a and the alternative instruction 101b are associated is stored in the storage unit 101, such a table may be embedded in a software program for performing preprocessing, or preprocessing may be performed. It may be provided independently of the software program for performing it.

In the above-mentioned pre-processing procedure, S
The processing in 104 is not limited to that shown in FIG.
For example, after the first stage process shown in FIG. 4, the second stage process may not be performed and “nop” may not be deleted.
In such a case, the intermediate code including “nop” may be executed as it is in the execution environment, or the class file may be deleted while deleting “nop” and changing the jump destination of the conditional branch in the execution environment. You may execute. Especially in the latter case, it is preferable to perform the above-mentioned preprocessing by utilizing the idle time in the execution environment.

[Second Embodiment] Next, an intermediate code execution system according to a second embodiment of the present invention will be described in detail with reference to FIGS. FIG. 5 shows a hardware configuration of an intermediate code execution system 2 according to the second embodiment of the present invention that executes a Java (R) class file as intermediate code. Intermediate code execution system 2
Is a storage unit 201, a processing unit 202, and an input unit 203.
Is equipped with. Incidentally, these storage unit 201 and processing unit 20
2 and the input unit 203 are substantially the same as the storage unit 101, the processing unit 102, and the input unit 103 of the intermediate code preprocessing device 1 according to the first embodiment. Further, the instruction pattern 201a and the alternative instruction 201b stored in the storage unit 201.
The class file 201c is stored in the storage unit 101 of the intermediate code preprocessing device 1 according to the first embodiment.
It is substantially the same as the instruction pattern 101a, the alternative instruction 101b, and the class file 101c. Therefore, duplicated description thereof will be omitted here.

The present embodiment mainly corresponds to the invention described in claim 3 or 17, and the storage unit etc. 2
01 corresponds to the storage means in the present invention, and the processing unit 202 corresponds to the processing means.

In the configuration as described above, the processing section 202
Each function of the intermediate code execution system 2 is realized by executing a series of software programs by
The class file 201c is preprocessed as described below, and the preprocessed class file 201c
Is executed.

FIG. 6 is a flow chart for explaining the procedure of preprocessing and execution of the class file 201c in this embodiment. This procedure is based on the premise that the class file 201c previously input from the input unit 203 is stored in the storage unit 201, as in the first embodiment.

First, the preprocessing of the intermediate code is started (S
201), the processing unit 202 stores the instruction pattern 201a and the alternative instruction 201 associated with each other from the storage unit 201.
The table of b is read (S202). Next, the processing unit 202 searches the class file 201c and specifies the command pattern 201a (S203). And the processing unit 2
02 designates the specified instruction pattern 201a as an alternative instruction 20
1b is replaced (S204), and the preprocessing of the intermediate code ends (S205). The above-mentioned processing is the same procedure as the pre-processing in the first embodiment, so detailed description will be omitted.

Next, the class file 201c which has been preprocessed as described above is executed. Here, a software program that is an interpreter capable of interpreting and executing the alternative instruction 201b with the same content as the instruction pattern 201a is executed, whereby the processing unit 20 is executed.
2 is a class file 201c stored in the storage unit 201
The instruction corresponding to the extracted instruction is executed by the processing unit 202 (S206) (S20).
7).

According to the intermediate code execution system 2 according to the second embodiment, the instruction pattern 201a is replaced with the alternative instruction 201b in the class file 201c by the above procedure.
It is possible to perform a pre-processing for replacing with, and execute the pre-processed intermediate code. Therefore, the code length of the class file 201c can be shortened, and the intermediate code in which redundant processing between instructions is omitted can be executed, whereby the performance at the time of executing the intermediate code can be improved. Furthermore, when executing the intermediate code after pre-processing, by interpreting and executing the alternative instruction as processing that minimizes overhead factors such as memory access,
It is also possible to further improve the performance when executing the intermediate code.

Although the procedure shown in FIG. 6 shows the case where the preprocessing and the execution of the class file are continuously performed,
The preprocessing and the execution of the class file may not necessarily be continuous, and the class file may be preprocessed in advance and the preprocessed class file may be executed after a while. .

The instruction pattern 201a associated with the alternative instruction 201b is not limited to one type,
Two or more kinds may be used. In such a case, in order to start the execution of the class file with the overhead of the preprocessing as small as possible when the preprocessing and the execution of the class file are continuously performed by the procedure as shown in FIG. ,
Command pattern 201 associated with alternative command 201b
It is also possible to perform the pre-processing for replacing a part of the command pattern of a with the alternative command.

Furthermore, the performance of the MPU and the microcontroller that form the processing unit 202 varies depending on the equipment in which the intermediate code execution system 2 is mounted, and the time margin for preprocessing and the equipment system depend on the situation. There is also a change in processing capacity. Therefore, when there are a plurality of command patterns associated with alternative commands, how many command patterns are to be replaced may be statically adjusted according to the characteristics and conditions of the device. By doing so, it is possible to realize the preprocessing according to the characteristics and the situation of the device in which the intermediate code execution system 2 is mounted. For example, when the intermediate code execution system 2 of the present invention is installed in a mobile phone, when a class file downloaded to the mobile phone is immediately executed, only some command patterns are replaced, and when the class file is not immediately executed. Adjustment may be made so that all instruction patterns are replaced. By doing so, it becomes possible to execute the class file on the mobile phone while performing preprocessing according to the situation.

[Third Embodiment] Next, an intermediate code execution system according to a third embodiment of the present invention will be described in detail with reference to FIGS. FIG. 7 is a diagram schematically showing an intermediate code execution system 100 according to a third embodiment of the present invention that executes a Java (R) class file as intermediate code. This intermediate code execution system 1
00 has an arithmetic unit 5 including an MPU or a microcontroller, and a storage unit 10 connected to the arithmetic unit 5.

The arithmetic section 5 constitutes an intermediate code analysis section 20 and intermediate code execution sections 30A, 30B and 30C by executing a predetermined software program.
Such a software program may be stored in the storage unit 10 or may be stored in another storage unit.

Intermediate code execution units 30A, 30B, 3
0C functions as an interpreter that sequentially interprets and executes the intermediate code. The intermediate code execution units 30A, 30B, 30C are of types having different processing characteristics. For example,
The intermediate code execution unit 30A is fast in processing the bytecode instructions F but slow in processing the bytecode instructions G, and the intermediate code execution unit B is fast in processing the bytecode instructions G but slow in processing the bytecode instructions F. It seems that the execution unit C has an average processing speed for any bytecode instruction.

Further, the intermediate code analysis unit 20 analyzes the property of the method included in the class file 12 stored in the storage unit 10, selects the intermediate code execution unit 30 according to the property, and selects the method. The processing of recording the combination with the intermediate code execution unit 30 that has been performed is performed. The processing performed by the intermediate code analysis unit 20 will be described in detail later.

The storage unit 10 has a RAM and a ROM,
A class file 12 and a correspondence database 13 are stored. The storage unit 10 may have a physically single configuration or a plurality of configurations.

The class file 12 is generated by compiling a source code file created in the Java (R) language, and includes one or more methods. This method is a set of a plurality of bytecode instructions for realizing a specific process. The correspondence database 13 is the intermediate code execution unit 30.
It is a database that manages the score of the processing efficiency of each bytecode instruction in each of A, B, and C.

The present embodiment mainly corresponds to the invention described in claim 4, and the intermediate code execution unit 30 is used.
A, 30B and 30C correspond to the intermediate code executing means in the present invention, the storage section 10 corresponds to the storing means, and the intermediate code analyzing section 20 corresponds to the intermediate code analyzing means.

FIG. 8 is a data structure diagram showing an example of specific contents of the correspondence database 13. As shown in FIG. 8, the correspondence database 13 stores the score of the processing efficiency of each bytecode instruction in each of the intermediate code execution units 30A, 30B, 30C.
Here, the processing efficiency score is a numerical value indicating how efficiently the bytecode instruction can be executed, and such a score is obtained by the intermediate code executing units 40A, 30B and 30C. It is preferable to define in advance according to the specifications of. The data structure shown in FIG. 8 is
The invention mainly corresponds to the invention described in claim 5.

For example, in the uppermost row of FIG. 8, the scores of the processing efficiency in each of the intermediate code execution units 30A, 30B, 30C of the bytecode instruction a are defined.
Specifically, the intermediate code execution unit 30 of the bytecode instruction a
The processing efficiency score in A is 90, the processing efficiency score in the intermediate code executing unit 30B is 10, and the processing efficiency score in the intermediate code executing unit 30C is 10 (here, the higher the numerical value, the higher the numerical value). Be efficient). Therefore, according to such a correspondence database 13, it is understood that the bytecode instruction a is most efficiently executed by the intermediate code execution unit 30A. Similarly, the bytecode instruction b,
c, and the processing efficiency score in each of the intermediate code execution units 30A, 30B, and 30C for all other bytecode instructions are defined in the correspondence relationship database 13. The score table of the processing efficiency according to claim 5 is stored in the correspondence database 13.

Hereinafter, with reference to the flowchart of FIG.
A procedure of processing executed by the intermediate code analysis unit 20 of the intermediate code execution system 100 according to the third embodiment will be described.
First, the intermediate code analysis unit 20 reads a method from the class file 12 of the storage unit 10 (S301). Next, the intermediate code analysis unit 20 analyzes the read method and identifies the bytecode instruction included in the method (S302). Since one method includes a plurality of bytecode instructions, the intermediate code analysis unit 20
Repeats the procedure of individually specifying a plurality of bytecode instructions included in the method.

Next, the intermediate code analysis unit 20 makes an inquiry to the correspondence database 13 in the storage unit 10,
The processing efficiency score corresponding to each bytecode instruction specified in S102 is acquired and summed (S303).

Thereafter, the intermediate code analysis unit 20 determines S30.
Intermediate code execution units 30A, 30B, 30 obtained in No. 3
An intermediate code execution unit capable of executing the class file 12 most efficiently is specified based on the total score of the processing efficiency in each C (S304). Specifically, the intermediate code analysis unit 20 may compare the total scores of the intermediate code execution units, and specify the one having the highest total score as the intermediate code execution unit used for executing the method. .

Finally, the intermediate code analysis unit 20 determines that the method is specified in S304.
It records what is to be executed with 0 (S305). Specifically, for example, in the management information held for each method,
The type of the intermediate code execution unit 30 to be executed may be recorded, or the type of the intermediate code execution unit 30 to be executed may be marked in the method.
The above operation is executed for all the methods included in the class file 12, and the intermediate code analysis unit 20 ends the process.

The contents of the processing in S303 and S304 will be described more specifically below by taking the correspondence database 13 shown in FIG. 8 as an example. Assuming that the method includes bytecode instructions a and d, the intermediate code analysis unit 20 is a score of the processing efficiency of the intermediate code execution unit 30A of the bytecode instruction a.
0, 10 which is the score of the processing efficiency in the intermediate code execution unit 30B, and 10 which is the score of the processing efficiency in the intermediate code execution unit 30C are acquired. Then
The intermediate code analysis unit 20 is a processing efficiency score of 5 in the intermediate code execution unit 30A of the bytecode instruction d.
0, 40 that is the processing efficiency score in the intermediate code execution unit 30B, and 90 that is the processing efficiency score in the intermediate code execution unit 30C are acquired and added to the score of the bytecode instruction a.

In this case, the total score of the processing efficiency in the intermediate code execution unit 30A is 140, the total score in the intermediate code execution unit 30B is 50, and the total score in the intermediate code execution unit 30C is 100. Therefore,
The intermediate code analysis unit 20 identifies the intermediate code execution unit 30A as the one used for executing the method. By performing the above-described processing, the intermediate code execution system 100 executes the method included in the class file 12 based on the contents recorded by the intermediate code analysis unit 20 and executes the bytecode included in the method. The most efficient intermediate code execution unit 30A determined according to the instruction,
It becomes possible to use 30B or 30C. Therefore, according to the third embodiment, it is possible to efficiently execute the method included in the class file 12 by utilizing the intermediate code execution units 30A, 30B, and 30C having different characteristics. An execution system 100 is provided.

[Fourth Embodiment] Next, an intermediate code execution system according to a fourth embodiment of the present invention will be described in detail with reference to FIGS. The intermediate code execution system according to the fourth embodiment has the same basic configuration as that of the third embodiment. However, in the intermediate code execution system according to the fourth embodiment, the intermediate code analysis unit 20 obtains the total value of the scores uniquely determined for each bytecode instruction included in the method, and ranks the total value. The third embodiment is different from the third embodiment in that one of the intermediate code execution units 30A, 30b, and 30C is specified accordingly. The present embodiment mainly corresponds to the invention described in claim 6.

Hereinafter, this point will be described in detail. In order to realize the above-mentioned identification method in the intermediate code analysis unit 20, the correspondence relationship database 13 in the fourth embodiment stores each bytecode instruction and the score of each bytecode instruction as shown in FIG. It includes a table that defines the correspondence relationship and a table that defines the correspondence relationship between the total score range and the intermediate code execution units 30A, 30B, 30C as shown in FIG.

Of these, the former will be described based on the example of FIG. 10. The left side of FIG. 10 shows each bytecode instruction, and the right side of FIG. 10 shows the value of the score set corresponding to it. There is. Here, the bytecode instruction a has a score of 40, and the bytecode instruction b has a score of 9
The score of 0 and the bytecode instruction c is uniquely set to 55. When the latter is explained based on the example of FIG. 11, the left side of FIG. 11 shows the range of the total score, and the right side of FIG. 11 is the intermediate code execution unit specified corresponding to the range of the total score. 30A, 30B, 30C
Indicates either. Here, the total score corresponding to a bytecode instruction included in a method is 201
When it belongs to the range below, the intermediate code execution unit 30A is specified. Similarly, the total score is 201 or more 401
It is set so that the intermediate code execution unit 30B is specified when the number is less than the above, and the intermediate code execution unit 30C is specified when the number is at least 401.

Intermediate code analysis unit 2 in the fourth embodiment
The basic procedure of the process executed by 0 is almost the same as that of the third embodiment. That is, as shown in FIG. 7, the intermediate code analysis unit 20 reads a method from the class file 12 of the storage unit 10 (S101), identifies a bytecode instruction included in the method (S102), and stores it in the correspondence relation database 13. Scores corresponding to each bytecode instruction identified by inquiry are acquired and summed (S103). After that, the correspondence relation database 13 is again inquired to specify the intermediate code execution unit corresponding to the total score (S10).
4) Then, record that the intermediate code execution unit that specified the method should be executed (S105), and terminate the process.

Hereinafter, taking the correspondence relation database 13 shown in FIGS. 10 and 11 as an example, the above S103 and S
The contents of the processing in 104 will be specifically described. Assuming that the method includes bytecode instructions a and c, the intermediate code analysis unit 20 determines that the bytecode instruction a
Of 40 and the score of bytecode instruction c of 55 are obtained, and the total value is 95 (ST1
03). The intermediate code analysis unit 20 calculates the total value and Fi
g. From the table of 11, the intermediate code execution unit 30A is specified as the one used for executing the method.

Also in the fourth embodiment for performing the above-mentioned processing, the most efficient intermediate code execution units 30A, 30B determined in accordance with the bytecode instructions included in the method or in the same manner as the third embodiment. Since 30C can be used, an extremely high performance intermediate code execution system 100 is provided.

[Fifth Embodiment] Next, an intermediate code execution system according to a fifth embodiment of the present invention will be described in detail with reference to FIGS. FIG. 12 is a diagram schematically showing an intermediate code execution system 200 according to the fifth embodiment of the present invention. This intermediate code execution system 20
0 has the same basic configuration as the third and fourth embodiments, but differs from the third and fourth embodiments in that it has a general intermediate code executing unit 31 and a special intermediate code executing unit 32. .

In this intermediate code execution system, the general intermediate code execution unit 31 and the special intermediate code execution unit 32 execute the class file 12. The general intermediate code execution unit 31 is an interpreter that sequentially interprets and executes a class file, and has a normal function of executing all bytecode instructions. On the other hand, the special intermediate code execution unit 32 can execute a specific bytecode instruction at a higher speed than the general intermediate code execution unit 31, but some instructions (for example, a bytecode instruction relating to floating-point arithmetic). ) Is a special interpreter that cannot execute.

Further, the correspondence relation database 13 in the fifth embodiment has a data structure for identifying, for each bytecode instruction, whether or not the bytecode instruction can be executed by the special intermediate code executing section 32. Has become.

The present embodiment mainly corresponds to the invention described in claim 7, the special intermediate code executing section 32 corresponds to the special intermediate code executing means in the present invention, and the general intermediate code executing section Reference numeral 31 corresponds to general intermediate code execution means, storage unit 10 corresponds to storage means, and intermediate code analysis unit 20 corresponds to intermediate code analysis means.

Hereinafter, with reference to the flowchart of FIG. 13, the intermediate code execution system 200 according to the fifth embodiment.
The procedure of the process executed by the intermediate code analysis unit 20 will be described. First, the intermediate code analysis unit 20 reads a method from the class file 12 of the storage unit 10 (S201).
Next, the intermediate code analysis unit 20 analyzes the read method and identifies a bytecode instruction included in the method (S202), and the identified bytecode instruction cannot be executed by the special intermediate code execution unit 32. Whether or not it is a code instruction is determined based on the contents of the correspondence database 13 (S203). If it is determined in S203 that the special intermediate code execution unit 32 does not include an inexecutable bytecode instruction, the intermediate code analysis unit 2
0 records that the method should be executed by the special intermediate code execution unit 32 (S204). On the other hand, when it is determined in S203 that the special intermediate code execution unit 32 includes a bytecode instruction that cannot be executed, the intermediate code analysis unit 20 records that the general intermediate code execution unit 31 should execute the method ( S205). The recording method may be the same as in the third and fourth embodiments. The above operation is executed for all the methods included in the class file 12, and the intermediate code analysis unit 20 ends the process.

According to the fifth embodiment as described above, the special intermediate code executing section 32 which can execute a specific bytecode instruction at high speed but cannot execute a part of the bytecode instruction, and all the instructions. By using the general intermediate code execution unit 31 capable of executing the following, for each method, it is possible to execute a specific bytecode instruction at high speed and to execute all the intermediate bytecode instructions. A code execution system 200 is provided.

[Sixth Embodiment] The intermediate code execution system according to the sixth embodiment of the present invention will be described in detail with reference to FIG. The intermediate code execution system 300 according to the sixth embodiment uses Java as the intermediate code.
The class file of (R) is executed. Then, as shown in FIG. 14, the intermediate code execution system 300 includes a storage unit 301 that mainly stores a class file 302, and a method virtually configured by executing a predetermined program by a processing unit (not shown). Analysis unit 3
07, a first subsystem 308 and a second subsystem 310.

The class file 302 stored in the storage unit 301 is obtained by compiling the source code created in the Java (R) language. This class file 302 includes methods 303 to
Includes 305.

The class file 302 is a compressed jar
It is delivered in the form of a file, and the intermediate code execution system 3
It may be extended by 00. Note that this jar file is an archive file that combines the class files required for operating Java (R) programs.
It is a file. However, in FIG. 14, the class file is already stored in the storage unit 301.

The first subsystem 308 has a first interpreter 309. The first interpreter 309 can sequentially interpret and execute the bytecode instructions included in the Java (R) class file. This first interpreter 3
09 is an instruction code set generated at compile time,
That is, here, it is an ordinary interpreter that supports all bytecode instructions generated by compiling a source code created in the Java (R) language.

On the other hand, the second subsystem 310 is
A preprocessing unit 311 having substantially the same configuration and function as the intermediate code preprocessing device described above, and a second interpreter 312.
And have. As described above, the preprocessing unit 311 replaces a specific bytecode command pattern with a corresponding alternative command so that the command patterns “iload”, “iload”, and “iadd” are replaced with “v_v_iadd”, for example. Processing is applied to each method of the class file 302. Further, the second interpreter 312 is configured to be able to interpret and execute an alternative instruction added to the method after the replacement in order to correspond to the method processed in this way.

More specifically, substituting a specific instruction pattern with an alternative instruction in the preprocessing unit 311 means that a combination of an opcode and an operand forming a specific instruction pattern is converted into an opcode and an operand of a newly defined alternative instruction. Means to replace it with the set. Incidentally, the operation code represents the operation of the instruction, and the operand represents the stack, register or the like which is the target of the instruction.

However, in the case of Java (R), since the opcode length is limited to 1 byte, the types of opcode cannot be freely increased. Therefore, in the sixth embodiment, an alternative instruction is normally assigned to an operation code to which another instruction is assigned, and the operation code is interpreted as an alternative instruction at the time of execution, and is substantially the same as the instruction pattern before replacement. Make sure you follow the steps.

That is, in the sixth embodiment, for example, the alternative instruction is assigned to the operation code to which the instruction of the floating point operation is assigned in the normal bytecode instruction. Then, in the second interpreter 312, the operation code is interpreted and executed in the same procedure as the instruction pattern before being replaced with the alternative instruction.

As described above, in the second subsystem 310, the method can be preprocessed by the preprocessing unit 311 and then executed by the second interpreter 312. However, in the above-described example, it becomes impossible for the second subsystem 310 to execute the method including the instruction of the floating point arithmetic.

The method analysis unit 307 analyzes the instructions included in the method to be executed, and accordingly determines the method as the first subsystem 308 and the second subsystem 31.
Select whether to execute 0 or 0. Then, the result is marked on the method. That is, the function of the method analysis unit 307 in the sixth embodiment corresponds to the function of the intermediate code analysis unit 20 in the fifth embodiment.

The present embodiment mainly corresponds to the invention described in claims 9 to 14, and the storage unit 301
Corresponds to the storage means in the present invention, and the pre-processing unit 3
Reference numeral 11 corresponds to preprocessing means, the first and second interpreters 309 and 310 correspond to first and second interpreters, and the method analysis unit 307 corresponds to intermediate code analysis means or a selection unit.

Next, a procedure for executing the method 303 included in the class file 312 by the intermediate code execution system 300 having the above configuration will be described. First, the method analysis unit 307 analyzes an instruction included in the method 303. For example, when the operation code of the alternative instruction is assigned to the operation code of the floating point operation instruction in the second subsystem 310 as described above, it is determined whether the method 303 includes the instruction of the floating point operation. Then, from the result, the subsystem to be used for executing the method 303 is determined to be the predetermined position 3 of the method 303.
Mark 06. That is, when it is determined that the method 303 includes a floating-point operation instruction, it is selected to be executed by the first subsystem 309. And
When it is determined that the method 303 does not include a floating point operation instruction, the second subsystem 310 is selected to execute it.

When the execution by the first subsystem 309 is selected, the method 303 is sequentially interpreted and executed by the first interpreter 309 as it is.

On the other hand, when it is selected to be executed by the second subsystem 310, the method 303 is preprocessed by the preprocessor 311 to substitute a fixed pattern formed by a plurality of instructions included in the method 303 as an alternative instruction. Replace with. Then, after this, the second interpreter 312 corresponding to the substitute instruction sequentially interprets and executes the instruction.

Then, as described above, the method 303
When the execution of the method is completed, the method 303 to 305 is successively executed according to the content of the class file 302 until the program is completed.

According to the configuration of the intermediate code execution system 300 and the procedure of method execution according to the sixth embodiment, some instructions cannot be executed, but a specific instruction pattern included in the method is replaced with an alternative instruction. The second subsystem 31 that can execute the method at high speed by omitting redundant processing between instructions
0, although the method execution speed has not been increased,
First subsystem 30 capable of executing all instructions
8 can be effectively operated, and the class file can be executed with excellent performance.

The first to sixth embodiments can be variously modified. For example, in the above-described first and second embodiments, the case where preprocessing is performed in class file units is shown, but in these embodiments, preprocessing may be performed in method units as in the sixth embodiment. Absent. Also,
The data structure in the correspondence database 13 in the third and fourth embodiments and the score setting therein are not limited to those described above.

Further, in place of the combination of the first subsystem 309 and the second subsystem in the sixth embodiment, it is possible to execute the preprocessor and the alternative instruction for replacing the specific instruction pattern with the alternative instruction. Two subsystems with an interpreter may be used. When such a combination of subsystems is used, it is possible to selectively use the two subsystems by assigning alternative instructions to different opcodes in the two subsystems. The number of subsystems may be three or more.

Further, in the sixth embodiment, the case where the preprocessing is performed at the time of executing the method in the second subsystem 310 is shown, but for the method executed once, the preprocessed method is stored in the storage unit 301. By doing so, the preprocessing may be omitted. Further, all methods may be analyzed by the method analysis unit 307 at the time of class loading, and preprocessing may be performed in advance for the method to be executed by the second subsystem 310. Furthermore, preprocessing may be performed at the time of compiling.

Further, when it is difficult to allow the memory consumption and the overhead in the analysis by the method analysis unit 307 and the preprocessing by the preprocessing unit 311, these are omitted and the method is executed in the first subsystem 308. It may be configured to. Furthermore, in the sixth embodiment, as an example, the case where the alternative instruction is assigned to the operation code to which the instruction of the floating point operation is assigned is shown, but the present invention is not limited to this. Alternate instructions may be assigned to opcodes to which other instructions have been assigned.

All of the first to sixth embodiments can be applied to the intermediate code obtained by modifying the Java (R) class file.
Any language other than a (R) can be applied as long as it is assumed to be executed by an intermediate code between the source code and the native code.

The first to sixth embodiments of the present invention have been described above. That is, according to the first and second embodiments, a predetermined instruction pattern is specified, and the specified instruction pattern is replaced with an alternative instruction which is a shortened code. Therefore, it is possible to reduce the number of types of instructions and obtain a new intermediate code in which redundant processing between instructions is omitted. Moreover, the size of the intermediate code is not increased by this preprocessing. In addition, the preprocessing itself can be executed at high speed because it only performs simple replacement. Furthermore, by executing the obtained new intermediate code in the execution system corresponding to the alternative instruction, the intermediate code can be executed at high speed.

According to the third embodiment, while the plurality of intermediate code execution units are provided in the device, the intermediate code analysis unit analyzes the intermediate code to be executed to efficiently execute the intermediate code. Select and record the appropriate intermediate code execution part. Therefore, the intermediate code can be executed at high speed by selecting the recorded intermediate code execution unit. Further, the correspondence relation between each bytecode instruction included in the intermediate code and the score of the processing efficiency in each intermediate code executing means is stored, and based on this, the intermediate code executing unit used for executing the intermediate code is specified. Therefore, it is possible to determine the appropriate intermediate code execution unit for efficient execution of the bytecode instruction based on the fine setting in consideration of the property of each intermediate code execution unit.

Further, according to the fourth embodiment, the correspondence relationship between each bytecode instruction included in the intermediate code and the processing efficiency score in the intermediate code execution unit, and the range of the score and the intermediate code specified accordingly. The correspondence relation with the execution unit is stored, and the intermediate code execution unit used for executing the intermediate code is specified based on these. Therefore, even when the number of prepared intermediate code execution units is large, there is no need to set and accumulate the processing efficiency score of each intermediate code execution unit.

Further, according to the fifth embodiment, two types of intermediate code execution units, that is, a special intermediate code execution unit and a general intermediate code execution unit are provided, and the special intermediate code execution unit includes a bytecode instruction that cannot be executed. Only the intermediate code is executed by the general intermediate code execution unit, while the other intermediate code is executed by the special intermediate code execution unit. Therefore,
Execution of intermediate code is extremely fast in the case where the output destination of intermediate code is selectively selected between the intermediate code execution section specialized for specific processing and the general-purpose intermediate code execution section. It is possible to provide a system that realizes

According to the sixth embodiment, although some of the instructions cannot be executed, a specific instruction pattern included in the method is inspected and executed as an alternative instruction to execute the instruction A second subsystem that can execute a method at high speed by omitting redundant processing and a first subsystem that can execute all instructions although speedup of method execution is not effective And can execute class files with excellent performance.

The present invention is not limited to the first to sixth embodiments described above, and various improvements and modifications can be made within the scope of the object thereof. For example, in the above-described third to fifth embodiments, the correspondence relationship between the bytecode instruction included in the intermediate code and the intermediate code execution unit suitable for efficient execution of the bytecode instruction is stored in advance. did. However, the present invention is not limited to this, and the correspondence may be changed according to the situation.
Further, by realizing at least a part of the interpreter function with a hardware accelerator, it is possible to increase the execution speed. Adopting this hardware accelerator has various advantages such as an increase in memory requirement and a method suitable for embedded devices.

[0104]

According to the present invention, the intermediate code executed by the virtual machine can be suitably applied to an intermediate code preprocessing device or an embedded device which improves the execution speed by preprocessing the intermediate code. It is possible to provide an intermediate code execution system capable of processing at high speed and a computer program product for preprocessing or executing the intermediate code.

[Brief description of drawings]

FIG. 1 is a block diagram showing a configuration of an intermediate code preprocessing device according to a first embodiment of the present invention.

FIG. 2 is a flowchart for explaining a process of performing preprocessing on the intermediate code by the intermediate code preprocessing device according to the first exemplary embodiment of the present invention.

FIG. 3 is a correspondence diagram for explaining the association between the intermediate code and the alternative instruction by the intermediate code preprocessing device according to the first embodiment of the present invention.

FIG. 4 is a diagram for explaining each step of a process of preprocessing an intermediate code by the intermediate code preprocessing device according to the first exemplary embodiment of the present invention.

FIG. 5 is a block diagram showing a configuration of an intermediate code execution system according to a second embodiment of the present invention.

FIG. 6 is a flowchart for explaining processing by the intermediate code execution system according to the second embodiment of the present invention.

FIG. 7 is a block diagram showing a configuration of an intermediate code execution system according to a third embodiment of the present invention.

FIG. 8 is a data structure diagram of a correspondence relation database 13 adopted by the intermediate code execution system according to the third embodiment of the present invention.

FIG. 9 is a flowchart showing an operation of the intermediate code analysis unit 20 in the intermediate code execution system according to the third exemplary embodiment of the present invention.

FIG. 10 is a data structure diagram of a correspondence database 13 adopted by the intermediate code execution system according to the fourth embodiment of the present invention.

FIG. 11 is a data structure diagram of a correspondence database 13 adopted by the intermediate code execution system according to the fourth embodiment of the present invention.

FIG. 12 is a block diagram showing the configuration of an intermediate code execution system according to a fifth embodiment of the present invention.

FIG. 13 is a flowchart showing an operation by the intermediate code analysis unit 20 adopted by the intermediate code execution system according to the fifth embodiment of the present invention.

FIG. 14 is a block diagram showing a configuration of an intermediate code execution system according to a sixth embodiment of the present invention.

[Explanation of symbols]

1 Intermediate code preprocessor 2 Intermediate code execution system 5 computing section 10 memory 12 class files 13 Correspondence D / B 20 Intermediate code analysis unit 30 Intermediate code execution unit 31 General intermediate code execution unit 32 Special intermediate code execution unit 101 storage unit 102 processing unit 103 input section 201 storage 202 processing unit 203 Input section

Claims (18)

[Claims] 1. An intermediate code preprocessing device for preprocessing an intermediate code obtained by compiling a source code created in a predetermined programming language, comprising: storage means for storing the intermediate code; and storage means for storing the intermediate code. An intermediate code preprocessing device, comprising: a processing unit that replaces a specific instruction pattern made up of a plurality of instructions included in the stored intermediate code with an alternative instruction that is associated with the specific instruction pattern in advance. . 2. The predetermined programming language is Java
The intermediate code preprocessing device according to claim 1, wherein the intermediate code is a (R) language, and the intermediate code is a Java (R) class file. 3. An intermediate code execution system for executing an intermediate code obtained by compiling a source code created in a predetermined programming language, comprising a storage means for storing the intermediate code and a processing means. Then, the processing means: a) processing for replacing a specific instruction pattern made up of a plurality of instructions included in the intermediate code stored in the storage means with an alternative instruction previously associated with the specific instruction pattern; b) When sequentially interpreting and executing the intermediate code in which the specific instruction pattern is replaced by the alternative instruction, interpreting and executing the alternative instruction in a process substantially equivalent to the specific instruction pattern. An intermediate code execution system characterized by executing processing and. 4. An intermediate code execution system for executing intermediate code obtained by compiling source code created in a predetermined programming language, a plurality of intermediate code executing means for executing the intermediate code, and the intermediate code. And an intermediate code analyzing means for storing a correspondence relationship between an instruction included in the intermediate code and the intermediate code executing means suitable for efficient execution of the instruction. Analysis means: a) processing for identifying an instruction included in the intermediate code stored in the storage means; and b) suitable for efficient execution of the intermediate code based on the identified instruction and the correspondence relationship. Performing a process of specifying the intermediate code executing unit, and c) executing a process of recording the relationship between the intermediate code and the specified intermediate code executing unit. The intermediate code execution system according to symptoms. 5. The correspondence between the instruction in the storage means and the intermediate code execution means suitable for efficient execution of the instruction is a score of processing efficiency when each instruction is executed by each of the intermediate code execution means. Including a table, the process of b) includes: b1) a process of acquiring a score of processing efficiency when the specified instruction is executed by each of the intermediate code executing means based on the score table; and b2) A process of summing the acquired scores for each intermediate code execution unit, and a process of specifying the intermediate code execution unit used for executing the intermediate code based on the score summed for each intermediate code execution unit. The intermediate code execution system according to claim 4, comprising: 6. The correspondence relationship between the instruction in the storage means and the intermediate code execution means suitable for efficient execution of the instruction corresponds to the value of the point assigned to each instruction and each of the intermediate code execution means. And a range of the total value of the points, the process of b), b1) a process of acquiring the point of the specified instruction based on the correspondence, and b2) a total value of the acquired points. 5. A process for obtaining, and b3) a process for specifying the intermediate code executing means used for executing the intermediate code based on the correspondence relationship and the obtained total value.
The intermediate code execution system described in. 7. An intermediate code execution system for executing all instructions in an intermediate code execution system for executing an intermediate code obtained by compiling source code created in a predetermined programming language, and a part of the general intermediate code execution means. A special intermediate code execution means capable of executing only instructions, a storage means storing the intermediate code, and an intermediate code analysis means, wherein the intermediate code analysis means is a) the intermediate code stored in the storage means And analyzing whether the instruction included in the intermediate code includes an instruction that the special intermediate code execution means cannot execute, and b) when determining that the instruction cannot be executed, When it is determined that the intermediate code is to be executed by the special intermediate code executing means, and it is determined that the unexecutable instruction is included, the intermediate code is stored. The intermediate code execution system and executes a process of recording should be performed in serial general intermediate code execution unit. 8. The predetermined programming language is Java
The intermediate code execution system according to claim 3, wherein the intermediate code is a (R) language, and the intermediate code is a Java (R) class file. 9. An intermediate code execution system for executing an intermediate code obtained by compiling a source code created in a predetermined programming language by an interpreter method, in a storage means storing the intermediate code, and in the storage means. Preprocessing means for replacing the stored intermediate code with a specific instruction pattern included in the intermediate code with an alternative instruction previously associated with the specific instruction pattern; and interpreting and executing the alternative instruction. A first interpreter that cannot perform the above, a second interpreter that can interpret and execute the alternative instruction in a content equivalent to the instruction pattern before replacement, and an intermediate code processed by the preprocessing means Then
It is determined whether or not the intermediate code includes the alternative instruction, and if the intermediate instruction is included, it is recorded that the intermediate code is to be executed by the first interpreter, and the alternative instruction is included. Is included, an intermediate code analysis system for recording that the intermediate code should be executed by the second interpreter. 10. In an intermediate code execution system for executing an intermediate code obtained by compiling a source code created in a predetermined programming language by an interpreter method, all the instructions generated by the compilation are interpreted and executed. A first subsystem having a first interpreter capable of performing the preprocessing, a preprocessing unit that performs a preprocessing that replaces an instruction pattern including a plurality of instructions included in the intermediate code with an alternative instruction, and A second interpreter capable of interpreting and executing substantially the same content as the instruction code;
A second subsystem having: and a process of executing the intermediate code by the first interpreter in the first subsystem according to an intermediate code to be executed, and a process by the preprocessing unit in the second subsystem. An intermediate code execution system comprising: a selection unit that selects one of a process to be executed by the second interpreter after preprocessing the intermediate code. 11. The second subsystem is the first subsystem.
The alternative instruction is assigned to the operation code to which the specific instruction is assigned in the subsystem of, and the selecting unit uses the first subsystem when the intermediate instruction to be executed includes the specific instruction. 11. The intermediate code execution system according to claim 10, wherein a process is selected, and when the intermediate code to be executed does not include the specific instruction, the process by the second subsystem is selected. 12. An intermediate code execution system for executing an intermediate code obtained by compiling a source code created in a predetermined programming language, the first instruction pattern consisting of a plurality of instructions included in the intermediate code. With a first alternative instruction, and a first interpreter capable of interpreting and executing the first alternative instruction into contents substantially equivalent to the instruction code before replacement. A pre-processing unit for performing pre-processing for replacing a second instruction pattern included in the intermediate code with a second alternative instruction, and an instruction code before replacement of the second alternative instruction A second subsystem having a second interpreter capable of being interpreted and executed as a content substantially equivalent to that of the first subsystem, and the second subsystem having the second subsystem according to the intermediate code to be executed. Either executing the intermediate code by the first interpreter or executing the intermediate code by the second interpreter after preprocessing the intermediate code by the preprocessing unit in the second subsystem. An intermediate code execution system, comprising: a selection unit for selecting. 13. The first subsystem assigns the first alternative instruction to a first opcode and the second subsystem assigns the second alternative instruction to a second opcode. The selecting unit selects the process by the second subsystem when the intermediate code to be executed includes the instruction related to the first opcode, and the intermediate code to be executed includes the instruction related to the second opcode. 13. The intermediate code execution system according to claim 12, wherein the process by the first subsystem is selected when the intermediate code execution system exits. 14. The predetermined programming language is Java
14. The (R) language, the intermediate code is a Java (R) class file, and the instruction is a Java (R) bytecode instruction. The intermediate code execution system described in. 15. An intermediate code preprocessing program for preprocessing an intermediate code obtained by compiling a source code created in a predetermined programming language, wherein the processing means specifies a specific code included in the intermediate code. An intermediate code preprocessing program that executes a process of replacing an instruction pattern with an alternative instruction previously associated with the specific instruction pattern. 16. The predetermined programming language is Java
16. The intermediate code preprocessing program according to claim 15, wherein the intermediate code is a (R) language, and the intermediate code is a class file including a Java (R) bytecode instruction. 17. An intermediate code execution program for executing an intermediate code obtained by compiling a source code created in a predetermined programming language, the processing means comprising: a) a plurality of instructions included in the intermediate code. Replacing the specific instruction pattern with an alternative instruction previously associated with the specific instruction pattern, and b) interpreting and executing the intermediate code in which the specific instruction pattern is replaced with the alternative instruction, An intermediate code execution program that executes a process of interpreting the alternative instruction as a process substantially equivalent to the specific command pattern and having low redundancy and executing the process. 18. The predetermined programming language is Java
The intermediate code execution program according to claim 17, wherein the intermediate code is a (R) language, and the intermediate code is a class file including a Java (R) bytecode instruction.