JP3424596B2 - Method and apparatus for caching symbol reference information - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention is used in an information processing apparatus that creates an execution module by compiling from an input file in a format that can be executed by an interpreter and executes it in cooperation with a prepared execution (runtime) environment. , And a method and apparatus for caching symbol reference information.

[0002]

2. Description of the Related Art A programming language is divided into a compiled language and an interpreted language by an interpreter, when distinguished from the execution form in an information processing apparatus. The former compiles a source program and converts it into a machine language that the computer can execute according to a specific computer architecture. C and COBOL are representative of this. The latter is once converted into an intermediate format program code, and is executed while sequentially interpreting the intermediate format program code by an interpreter. This does not require compile processing, but it has a drawback that the execution speed is slow because sequential conversion is required at the time of execution.
a also corresponds to this. On the other hand, a hybrid compiler interpreter having the advantages of both the compiler and the interpreter is disclosed in Japanese Patent Laid-Open No. 6-230976, "Method and Apparatus for Resolving References". Detailed description is provided herein of a method and apparatus for generating executable code by a compiler, and resolving data references in the generated code by an interpreter that interprets the compiled code.

[0003]

By the way, with the interpreter alone, in the resolution processing of symbols such as methods, objects and constants, the reference position is recorded at the first access and the recorded reference position is directly accessed after the second access. To access the substance of this symbol information. As a mechanism for this, by rewriting the instruction itself after executing the first instruction, it is possible to quickly determine whether or not the symbol resolution processing is completed and execute it. However, the execution module generated by the compiler is processed regardless of the symbol resolution managed by the interpreter. Therefore, as disclosed in the above publication, when the interpreter and the native code are mixed and executed in cooperation, the symbol resolution processing unrelated to the interpreter causes a problem in executing the program through the interpreter. Also, because the instructions cannot be rewritten,
It has been desired to introduce a method and apparatus for performing a solution process without sacrificing execution speed. The present invention has been made in view of the above circumstances, and in an information processing device that creates an execution module by compilation from an input file in a format that can be executed by an interpreter and executes the module in cooperation with a runtime environment prepared in advance, a storage area It is an object of the present invention to provide a symbol reference information cache method and apparatus capable of minimizing the above-mentioned requirement and improving the operation speed at the time of execution.

[0004]

According to a first aspect of the present invention, there is provided a method of caching symbol reference information according to the first aspect of the invention.
Create an execution module by compiling the program with a compiler , and execute this execution module.
And the execution of the second input program by the interpreter
In the information processing apparatus to execute in cooperation with the co
The compiler is for symbol management in the interpreter.
Execution module that internally has the same integer array as the integer array
And the execution module returns the first symbol resolution.
When processing is executed, the symbol is passed through the interpreter.
The pointer information to the symbol entity
By recording the information in the integer array provided internally,
The target symbol has been resolved in the subsequent processing.
It is characterized in that whether or not the execution module is used is distinguished . A symbol information cache method according to a second aspect is the symbol information reference method according to the first aspect, wherein an initial value is recorded in an integer array provided in the execution module, and the target symbol is Already resolved
The initial value is entered in the integer array to distinguish whether it has been done or not.
It is characterized by distinguishing whether or not there is .

According to another aspect of the present invention, there is provided a symbol information cache device having a first input in a form executable by an interpreter.
By compiling the program with a compiler
Ri to create an executable module, the execution of the execution module
And the execution of the second input program by the interpreter
In the information processing apparatus to execute in cooperation with the co
The compiler is for symbol management in the interpreter.
Execution module that internally has the same integer array as the integer array
And a means for outputting the first execution
When executing the symbol resolution processing, the interpreter
At the same time as symbol resolution via the
Record pointer information of the above into the integer array provided inside
By doing so, the target symbol is resolved in the subsequent processing.
It is characterized in that whether or not processing has been performed is distinguished by the execution module alone .

In the above-described structure, the management array is uniquely provided, and at the time of the first solution processing, the result is recorded in the execution module at the same time as the internal processing of the interpreter, and thereafter, the result is used so that the overhead caused by the solution processing is eliminated. Mitigation can be achieved. In particular, it is expected that the execution speed will be greatly improved in a program in which the same function is called many times or the same variable is accessed many times. Further, regarding a symbol that can be statically determined at the time of compilation, by holding the result in the execution module at the time of compilation, it is possible to significantly reduce the processing speed of any program.

[0007]

FIG. 1 is a block diagram showing an embodiment of the present invention. In the figure, 1 is an input program to be executed in an interpreted manner.
Code compiler (hereinafter simply referred to as compiler 2)
It is also supplied to the interpreter system 5. Reference numeral 3 is an assembly code file converted and output by the compiler 2. Reference numeral 4 is an execution module obtained by converting the assembly code generated by the compiler 2 into a load module in the execution format. An interpreter system 5 sequentially interprets and executes the input program 1. The input program 1 is a file in a format that can be sequentially interpreted and executed by the interpreter system 5, and at the time of execution, the execution module 4 is called from a program module constituting the interpreter system 5 and starts operation. Even after the execution is started, the interpreter system 5 is called up as needed. The compiler 2 takes as input a file in a format that can be interpreted and executed by the interpreter system 5, reads its contents, and performs an equivalent process.
Is generated and output. In the assembly code Fal 3,
An integer array for symbol management such as variables and functions in the interpreter system 5 is provided, and "0" is recorded as an initial value. The assembly code file 3 generated and output here is converted into the execution module 4 using a normal assembler or the like.

2 and 3 are views quoted for explaining the operation of the embodiment of the present invention shown in FIG. 1, respectively.
It is a figure which shows the operation | movement outline | summary at the time of executing an execution module and an interpreter code together, and the outline | summary of the symbol resolution process by an interpreter system and an execution module. Figure 2
Execution module 4 and interpretive system 5, and
It is a schematic representation of how the input programs 1 and 6 read and executed by the interpreter system 5 cooperate and execute. The input program 1 is the same as the input program in FIG. 1, and is the code before conversion of the execution module 4. The input program 6 is a program that is called from the input program 1 or that is called and executed. FIG. 3 is a diagram quoted for explaining the symbol resolution processing, and the interpreter system 5
Operates with the input programs 1 and 6 as inputs, but the symbols 11 such as methods, objects, and constants are referenced from the management array (symbol pointer array) 10 using pointers, and are used as operands of instructions. , It has the index of the array and has a mechanism to access the entity. When the interpreter system 5 is executed alone, the instructions and operands are rewritten and the symbols 11 such as methods and objects are directly specified. This rewriting operation of the operand reference is called symbol resolution processing.

The operation of the embodiment of the present invention shown in FIG. 1 will be described in detail below with reference to FIGS.
At the time of execution, the execution module 4 is used for execution, but the execution module 4 calls and executes the interpreter system 5 for object access, method call, etc. which the execution module 4 does not have. When executing in this way, the variables and constants that are closed in the input program 1 can be managed and executed independently by the native.
The objects and methods in the input program 1,
If there is a possibility of accessing from another program module 6, such as a constant,
Since the interpreter system 5 may be interpreting and executing, the execution module 4 and the interpreter system 5
A system for cooperation is required.

Here, regarding the method, the execution module 4 is accessed through the interpreter system 5, and regarding the object, the input program 1 is used, and this is input to the interpreter system 5, and the interpreter system 5 alone is used. It is managed in the same way as it is executed. When the execution module 4 is executed, even when accessing those objects, the input program 1
Object management format. Also, when accessing a method or object of the module 6 other than the input program, the method is called through the interpreter system 5, and the object is called by the interpreter system 5.
Access. The execution of the execution module 4 and the interpreter system 5 in cooperation with each other is hereinafter referred to as mixed execution (execution module and interpreter code). When the interpreter system 5 alone is executed, the symbol information can be accessed at high speed by using the pointer of the operand after the second access by the above-described symbol resolution processing.

Here, the problem is that in the mixed execution of the interpreter system 5 and the execution module 4, the execution of the interpreter system 5 is slower than the execution of the execution module, and the symbol solving process through the interpreter system 5 is performed. Also, the processing for checking whether the symbol has been resolved is a factor that slows down the processing of the execution module 4, like the execution.
If the mechanism in the interpreter system 5 is used, the symbol resolution process can be performed only once for accessing the same symbol, but in mixed execution with the execution module 4, it is necessary to check whether or not the symbol has been resolved. Therefore, mixed execution with the interpreter system 5 is required. Therefore, when the compiler 2 outputs the assembly code file 3, the assembly code file 3 is provided with an integer array (symbol pointer pointer) for symbol management of objects and methods in the interpreter system 5.
An array) 10 is prepared and "0" is given as an initial value. At the time of the first symbol resolution processing, the symbol resolution is performed through the interpreter system 5, and at the same time, the information of the pointer to the substance of the symbol is recorded in the integer array 13 in the execution module 4. Since the symbol also has information that can be determined at compile time such as reference to a constant, such information is determined at compile time and the constant and the like are recorded at the output stage of the assembly code file 3. The determination as to whether to make the decision at the compile stage or the first execution is made based on whether the integer array contains "0" or any other value.

By these processes, the execution module 4
With respect to the symbol reference from, the symbol resolution processing can be limited to the first one at the time of compilation or at the time of execution, and whether or not the symbol has undergone the resolution processing can be processed by the execution module 4 alone. That is, the execution speed can be increased. An address or a constant is obtained in the symbol resolution process. In the case of a constant, there is a possibility that "0" will be entered depending on the resolution process, but in that case, it is determined that the resolution is unsolved and no problem occurs even if the resolution process is executed. In addition, it can be said that there is almost no case where "0" is entered due to the nature of the program, and the influence on the processing speed is minimized.

[0013]

The processing speed of the interpreter is slower than the operation of the execution module 4, and how to reduce the processing of the interpreter is an important design item for improving the processing speed. For native code that cannot be rewritten, how to reduce the overhead due to resolution processing is an important design item for improving the processing speed. It is possible to use the internal mechanism of the interpreter to perform the resolution process only once, but mixed execution with the interpreter will not disappear. Therefore, by having its own management array and recording the result in the execution module at the same time as the internal processing of the interpreter at the time of the first solution processing, the overhead associated with the solution processing can be reduced by using it. The invention is particularly
It is expected to greatly improve the execution speed in a program that calls the same function many times or accesses the same variable many times. Further, regarding a symbol that can be statically determined at the time of compilation, by holding the result in the execution module at the time of compilation, it is possible to significantly reduce the processing speed of any program.

[Brief description of drawings]

FIG. 1 is a block diagram showing an embodiment of the present invention.

FIG. 2 is a diagram showing an outline of operations during mixed execution by an execution module and an interpreter according to the embodiment of the present invention in FIG.

FIG. 3 is a diagram showing an outline of symbol resolution processing of the embodiment of the present invention in FIG.

[Explanation of symbols]

1 (6) ... Input program, 2 ... Interpreted
Code compiler (compiler), 3 ... Assembly
Code file, 4 ... Execution module (load module), 5 ... Interpreter system, 10 ... Array for symbol management, 11 ... Symbols

─────────────────────────────────────────────────── ─── Continuation of front page (56) Reference JP 62-113244 (JP, A) JP 6-230976 (JP, A) JP 10-111801 (JP, A) JP 7- 168718 (JP, A) (58) Fields surveyed (Int.Cl. ⁷ , DB name) G06F 9/45

Claims (3)

(57) [Claims] 1. A first form of a form executable by an interpreter .
Compile the input program with a compiler
Create an executable module by, of the execution module
Execution and execution of the second input program by the interpreter
In an information processing device that executes lines in cooperation with each other , the compiler is a symbol in the interpreter.
Execution module that internally has the same integer array as the management integer array
Is output to the execution module when the first symbol resolution process is executed.
In, the symbol resolution is done via the interpreter.
At the same time, the pointer information to the substance of the symbol is internally
Subsequent processing by recording in the provided integer array
To determine whether the target symbol has undergone resolution processing.
A method of caching symbol reference information, characterized by distinction by line module alone . 2. An initial value is recorded in an integer array provided in the execution module, and the target symbol has already been recorded.
Whether the resolution processing has been performed or not is initially set in the integer array.
The method of caching symbol reference information according to claim 1, wherein the method is distinguished by whether or not there is a value . 3. A first form of a form executable by an interpreter .
Compile the input program with a compiler
Create an executable module by, of the execution module
Execution and execution of the second input program by the interpreter
In an information processing device that executes lines in cooperation with each other , the compiler is a symbol in the interpreter.
Execution module that internally has the same integer array as the management integer array
Module for outputting the first symbol resolution processing
In, the symbol resolution is done via the interpreter.
At the same time, the pointer information to the substance of the symbol is internally
Subsequent processing by recording in the provided integer array
To determine whether the target symbol has undergone resolution processing.
A symbol reference information cache device characterized by distinction by line module alone .