JP2004126739A - Name resolution method - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a name resolution method that reduces a workload for member resolution without lowering the execution efficiency of processing even if inheritance relations among members are hierarchic, in a dynamically linked object-oriented program execution system. <P>SOLUTION: In consideration of many resolutions of the same member for the same instance in the same instruction point due to locality of data reference, information on instances to be executed at member resolution is saved, and at a member resolution for the same instance as before, the saved information is used for the member resolution, so that computational complexity for member resolution is reduced. <P>COPYRIGHT: (C)2004,JPO

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention relates to a method for executing an object-oriented program that performs dynamic linking, and more particularly to a name resolution method for determining a method to be executed.
[0002]
[Prior art]
In recent years, in information processing equipment, information communication equipment, and information home appliances, the amount of software development and required system resources have increased, and accordingly, efficient development methods and system configurations have been demanded. On the other hand, a system configuration for developing a program execution system using object orientation and performing dynamic linking is used.
In an object-oriented program execution system that performs dynamic linking, the name resolution process of a member that has performed class inheritance includes a member resolution process of a class specified by an execution instruction, and thereafter, an execution target instruction is executed based on class member information. There is a need to perform member resolution processing for the execution target instance to be processed. In order to increase the execution efficiency in such name resolution processing, a technique for skipping the member resolution processing of the class specified by the execution instruction by caching the member resolution information of the class specified by the execution instruction has been developed. There is known a technique for improving the execution efficiency of a program (for example, see Non-Patent Document 1).
[0003]
[Non-patent document 1]
Sun Microsystems, Inc. "The JavaTM Virtual Machine Specification (first
edition) "
[0004]
[Problems to be solved by the invention]
However, in the above-described conventional technology, when the inheritance relationship of members is multi-layered, the amount of calculation for solving a member for an instance increases, which causes a problem that the execution efficiency of the original processing is reduced.
[0005]
This is because, due to the locality of data reference, in the same instruction location, the same member is often resolved in the same instance, and every time an instruction that requires name resolution is executed, the member processing for the instance is performed every time. This is because the processing amount of the member solution occupying becomes enormous, and the execution efficiency of the processing originally desired to be executed is reduced.
[0006]
Further, in the above-described conventional technology, the rewriting process is also performed for the execution instruction on the ROM. Therefore, inconsistency occurs between the cache memory and the real memory, and the execution instruction portion on which the rewriting process has been performed is not expected. May behave differently incorrectly.
[0007]
SUMMARY OF THE INVENTION The present invention has been made to solve the above problems, and a name for reducing the processing amount required for member resolution without lowering the execution efficiency of processing even if the inheritance relationship of members is multi-layered. The purpose is to provide a solution.
[0008]
[Means for Solving the Problems]
In order to solve this problem, the present invention provides a method for executing a class file obtained by compiling an object-oriented program that performs dynamic linking with a predetermined compiler, and includes an execution target described in the class file. Is a name resolution instruction that requires name resolution, the step of resolving the name of the class member specified in the instruction of the execution target, based on the information of the class member that resolved the name, Resolving the name of the member for the instance that has become, caching, as member information, the member for the resolved instance and the class of the execution target instance that inherits the member as member information, A name resolution instruction that requires a name resolution is Replacing with another name-resolved name-resolved instruction indicating that the cached member is being executed, and when the name-resolved instruction requiring the name resolution is executed again, The same as the class having the entity, or when it is the same as the cached execution target instance class, performing a name resolution using the member information stored in the cache, From the second time onward, processing is performed using the cached member information.
[0009]
Also, in the present invention, the class file is arranged in a read-only storage unit or a readable / writable storage unit, and the caching step is performed only when the execution target instruction is arranged in the readable / writable storage unit. The step of caching the resolved member information is characterized in that the member information is arranged in the readable / writable storage unit, and the process is performed from the second time onward using the cached member information.
[0010]
In the present invention, the class file is arranged in a read-only storage unit or a readable / writable storage unit for each class, and the class is arranged in the read-only storage unit as information of each class. Or a writable flag, which is information for identifying whether the class file is located in the readable / writable storage unit, and the step of caching comprises: storing the class file in the readable / writable storage unit based on the writable flag. The step is a step of caching the resolved face information only when it is determined that the information is arranged.
[0011]
BEST MODE FOR CARRYING OUT THE INVENTION
Hereinafter, embodiments of the present invention will be described with reference to the drawings.
[0012]
FIG. 1 is a functional block diagram illustrating an example of a configuration of a program execution device that performs a name resolution method according to an embodiment of the present invention.
[0013]
In FIG. 1, the program execution device includes a program execution unit 4000, a read-only storage unit 2000, and a readable / writable storage unit 3000. Here, it is assumed that the input to the program execution unit 4000 is a class file (hereinafter, referred to as a class file 1000) obtained by compiling a program described in an object-oriented language by a predetermined compiler. Note that Java (R) and C ++ are typical object-oriented languages.
[0014]
The read-only storage unit 2000 stores a class group serving as a library. Note that the class group serving as a library can also be stored in the readable / writable storage unit 3000. In that case, it is only necessary to include the program execution unit 4000 and the readable / writable storage unit 3000.
[0015]
The readable / writable storage unit 3000 is a storage destination when the class 1000 is executed, and is a storage area for information necessary in the course of execution by the program execution unit 4000.
[0016]
The class reading unit 4100 reads the designated class 1000 according to the instruction from the execution instruction determination unit 4200, arranges the class 1000 in the readable / writable storage unit 3000, and writes the class in the readable / writable storage unit 3000. A value indicating writable is set in the flag. Note that writable means being located in a readable and writable RAM area.
[0017]
When the execution start is instructed, the execution instruction determination unit 4200 acquires the instruction to be executed from the readable / writable storage unit 3000 and determines the acquired instruction to be executed. If it is determined based on the type of the instruction to be executed that the instruction does not require name resolution, the instruction to be executed is notified to the instruction execution unit 4700, and the name resolution information whose name resolution information is already cached is read. If it is determined that the instruction is an instruction, the process proceeds to the resolution member information comparison unit 4800; otherwise (an unresolved name resolution instruction), the class reading unit 4100 is instructed to read a class to be executed and executed. The designated class member solving unit 4300 is notified of the class member information attached to the execution instruction.
[0018]
The execution designation class member solving unit 4300 resolves the class member information attached to the execution instruction notified from the execution instruction determination unit 4200, and notifies the instance member solving unit 4400 of the resolved class member information.
[0019]
The instance member resolving unit 4400 resolves the member name of the instance in which the execution target instruction is to be processed and executed based on the notified class member information, and executes the execution instruction existence location determination unit. 4500 is instructed.
[0020]
The execution instruction existence location determination unit 4500 checks the writable flag of the class having the substance of the method having the instruction to be executed, and if the value of the writable flag indicates writable, saves the resolution member information and rewrites the instruction. The process is shifted to the instruction execution unit 4700 if not.
[0021]
The resolved member information storage / instruction rewriting unit 4600 stores in the readable / writable storage unit 3000, as resolved name information, the resolved member information and the information of the instance class that is the execution target of the currently executed instruction as a processing target. The execution target name resolution instruction is rewritten to a name resolved name resolution instruction to which information that can refer to the name resolved information is added, and the instruction execution unit 4700 is notified of the name resolved name resolution instruction.
[0022]
The instruction execution unit 4700 executes the notified execution target instruction, and stores the execution result in the readable / writable storage unit 2000.
[0023]
The resolution member information comparison unit 4800 acquires the name resolved information stored in the readable / writable storage unit 3000, and determines the class of the instance in which the execution target instruction is to be processed as the processing target, and the name of the name resolution information. Either matches the class that holds the entity of the member indicated by the member information, or the class of the instance for which the execution target instruction is to be processed matches the class indicated by the execution target instance class information of the name resolved information Is determined. If any of them matches, the member information of the name resolved information is notified to the instruction execution unit 4700 as the resolution information of the member of the instance whose execution target instruction is to be processed. If none of them matches, the member information of the name resolved information is notified to the instance member resolving unit 4400 as the resolution information of the resolved class member specified in the execution target instruction.
[0024]
FIG. 2 shows a processing flow of the name resolution method according to the embodiment of the present invention. An operation procedure in which a program execution device receives an instruction to start execution, acquires an instruction to be executed, and executes the instruction. First, upon receiving an instruction to start execution, the execution instruction determination unit 4200 acquires an execution target instruction from the read-only storage unit 2000 or the readable / writable storage unit 3000 based on the instruction, and starts processing.
[0025]
The execution instruction determination unit 4200 determines whether the execution target instruction is a name-resolved name resolution instruction or not based on the acquired instruction type of the execution target instruction (S4201).
[0026]
If the instruction to be executed is a name-resolved name resolution instruction (YES in S4201), the process proceeds to the resolution member information comparison unit 4800, and the flow shifts to S4801.
[0027]
If the instruction to be executed is not a name-resolved name resolution instruction (NO in S4201), it is determined whether the instruction is a name resolution instruction (an unresolved name resolution instruction) or not (an instruction that does not require name resolution) ( S4202).
[0028]
If the instruction to be executed is an instruction that does not require name resolution (S4202: NO), the instruction executing unit 4700 executes a process specified for the instruction to be executed, and stores the result in the readable / writable storage unit 3000. And the process ends (S4701).
[0029]
If the execution target instruction is an unresolved name resolution instruction (S4202: YES), it instructs the class reading unit 4100 to read the execution target class, and causes the execution designated class member resolution unit 4300 to attach the execution instruction to the execution instruction. The notified class member information is notified (S4100). The processing in the class reading unit 4100 will be described later with reference to FIG.
[0030]
The execution-designated class member resolving unit 4300 resolves the notified class member information, and notifies the instance member resolving unit of the resolved class member information (S4301).
[0031]
The instance member resolving unit 4400 resolves the member name of the instance for which the execution target instruction is to be processed based on the notified class member information, and sends the execution instruction existence location determination unit 4500 The processing is shifted (S4401).
[0032]
The execution instruction existence location determination unit 4500 checks the rewritable flag of the class holding the method in which the execution target instruction exists (S4501). If the value of the rewritable flag does not indicate rewritable (NO in S4501), the instruction executing unit 4700 executes a process specified for the instruction to be executed, and stores the result in the readable / writable storage unit 3000. Then, the process ends (S4701). If the value of the rewritable flag indicates rewritable (YES in S4501), the solution member information storage / command rewriting unit 4600 stores the name resolved information in the readable / writable storage unit 3000 (S4601), and further executes The target name resolution instruction is rewritten to a name resolved name resolution instruction having rewritable information, and the instruction execution unit 4700 is notified of the name resolved name resolution instruction (S4602).
[0033]
The instruction executing unit 4700 executes a process specified for the instruction to be executed, stores the result in the readable / writable storage unit 3000, and ends the process (S4701).
[0034]
The resolution member information comparison unit 4800 acquires the name resolved information from the readable / writable storage unit 3000 (S4801).
[0035]
The resolution member information comparison unit 4800 determines whether the class of the instance in which the execution target instruction is to be processed is the same as the class holding the entity of the member indicated by the member information of the name resolved information, or It is determined whether the class of the instance for which the instruction is to be processed as the processing target matches the class indicated by the execution target instance class information of the name resolved information (S4802).
[0036]
If any of them matches (YES in S4802), the member information of the name resolved information is set as the resolution information of the member of the instance which is the execution target instruction as the processing target (S4803), and the instruction execution unit 4700 Executes the process specified for the instruction to be executed, stores the result in the readable / writable storage unit 3000, and ends the process (S4701).
[0037]
If none of them match (NO in S4802), the member information of the name resolved information is set as the resolution information of the class member specified by the execution target instruction, and the process is moved to the instance member resolution unit 4400, and S4401 is executed. Transitions to.
[0038]
FIG. 3 shows a part of the flow of processing of the name resolution method according to the embodiment of the present invention, and shows an operation procedure of the class reading unit 4100. This is a detailed view of S4100 in FIG.
[0039]
The class reading unit 4100 reads the designated class 1000 according to the instruction from the execution instruction determination unit 4200, and arranges the class 1000 in the readable / writable storage unit 3000 in an executable state (S4101).
[0040]
Next, the class reading unit 4100 sets a value indicating writable to the writable flag of the class in the executable state, which is arranged in the readable / writable storage unit 3000, and ends the process (S4102).
[0041]
FIG. 4 is a diagram illustrating an example of a configuration of information used by the name resolution method according to the embodiment of the present invention.
[0042]
The information used for processing includes a class 9100, a member table 9200, a field table 9300, a method table 9400, a method 9500, name resolved information 9600, and a method execution code 9700. The method execution code is a method program consisting of one or more execution instructions.
[0043]
The class 9100 has information of another class 9100 which is a super class, a member table 9200, and information of a writable flag, which are information of each class arranged in an executable state. A super class is a parent class (base class) that has an inheritance relationship.
[0044]
The writable flag is a storage unit of information that can identify whether the class is arranged in the read-only storage unit or the read-write storage unit.
[0045]
The member table 9200 has information of a field table 9300 and a method table 9400 held by each class.
[0046]
The field table 9300 has field information that each class and case class instance has as an entity.
[0047]
The method table 9400 has information on methods that each class and an instance of each class have as an entity.
[0048]
The method 9500 has information on a method attribute of each method and an execution code 9700 of the method. Method attributes include the class to which they belong, access restrictions of methods, arguments, return values, pointers to execution code, execution code length, stack size required for execution, local variable area size required for execution, and jump destination information when an exception occurs Consists of
[0049]
The name resolved information 9600 has information of a method 9500 or any field in the field table 9300 as information of a member whose name has been resolved, and has information of a class 9100 that inherits the member 9500.
[0050]
The method execution code 9700 has the code of the program actually executed by the method 9500. The name-resolved name resolution instruction rewritten in this code has the information of the name-resolved information 9600.
[0051]
As described above, when the name-resolved name resolution instruction is executed again, and when the same object as the object (instance or class) previously executed is the object to be executed, the name is already resolved and held. By using the information, the name resolution process can be completed with a small amount of calculation.
[0052]
【The invention's effect】
As described above, according to the present invention, the execution target class member holds the substance of the execution target class member by caching the execution target class member and the execution target instance class for the name resolution instruction. Even if not, it is possible to use the locality of data reference to reduce the calculation load required for member resolution for the second and subsequent times.
[0053]
Further, in a system in which the name resolution instruction to be executed is in both the read-only storage unit and the readable / writable storage unit, and the class is arranged in either the read-only storage unit or the readable / writable storage unit, At the time of placement in either the read-only storage unit or the readable / writable storage unit in the executable state, a writable flag that determines which storage unit is located is set, and the name to be executed is set. Refers to the writable flag of the class that holds the entity of the member having the resolution instruction, and if it exists in the readable / writable storage unit, caches the execution target class member to determine whether the execution target instruction can be rewritten. To reduce the computational load required for name resolution in the second and subsequent times by utilizing the locality of data reference, and to reduce the load between the cache memory and the real memory. Does not occur.
[Brief description of the drawings]
FIG. 1 is a functional block diagram illustrating an example of a configuration of a program execution device that implements a name resolution method according to an embodiment of the present invention. FIG. 2 is a flowchart of a processing flow of the name resolution method according to an embodiment of the present invention. FIG. 3 is a flowchart illustrating an example of the process. FIG. 4 is a flowchart illustrating an example of a process flow in a class reading unit according to the embodiment of the present invention. Diagram showing an example [Description of reference numerals]
1000 class 2000 read-only storage unit 3000 readable / writable storage unit 4000 program execution unit 4100 class read unit 4200 execution instruction determination unit 4300 execution designation class member resolution unit 4400 instance member resolution unit 4500 execution instruction existence location determination unit 4600 resolution member information storage -Instruction rewriting unit 4700 Instruction execution unit 4800 Resolution member information comparison unit 9100 Class 9200 Member table 9300 Field table 9400 Method table 9500 Method 9600 Name resolved information 9700 Method execution code

Claims (3)

A method for executing a class (or a class file that is a file in class units) obtained by compiling an object-oriented program that performs dynamic linking with a predetermined compiler, wherein an execution instruction stored in the class is a name A name resolution instruction that requires resolution,
Resolving the name of a class member specified in the instruction to be executed;
Resolving the name of the member for the instance being executed based on the information of the class member that has resolved the name;
Caching, as member information, a member for the resolved instance and information on a class of an execution target instance that inherits the member, and resolving a name obtained by resolving the name resolution instruction that requires name resolution as the execution target instruction. Replacing it with another name-resolved name-resolved instruction that indicates that it is cached;
When the name resolution instruction requiring name resolution is executed again, the execution target instance class is the same as the class having the cached member entity or the same as the cached execution target instance class. Performing a name resolution using the member information stored in the cache. The class is arranged in a read-only storage unit or a readable / writable storage unit,
2. The method according to claim 1, wherein the caching step is a step of caching the resolved member information only when the execution target instruction is arranged in the readable / writable storage unit. The class is arranged in a read-only storage unit or a readable / writable storage unit in class units,
As information of each class, the class has a writable flag as an information storage unit capable of identifying whether the class is arranged in a read-only storage unit or a readable / writable storage unit,
3. The method according to claim 2, wherein the caching step is a step of caching the resolved face information only when it is determined based on the writable flag that a class is arranged in the readable / writable storage unit. Name resolution method described.

Images