JPH03257530A - Execution processing system for object-based program - Google Patents

Abstract

PURPOSE:To attain a fast search even if the description of the method definition is shared with objects by taking out the method definition while referencing to the method selection information on an object when the method of the object is called out at the execution of a program. CONSTITUTION:A class and a method are defined or set in a preprocessing step, and the classes forming an object to be generated are designated for the acquisition of a class list. Then the method selection information are collected from each class for the production of the method selection information on the object. An editing operation needed in an postprocessing step is carried out for the generation of an object having a prescribed internal structure. When a method is called out, the required method is checked in order to check the presence or absence of methods of the same form. Thus it is possible to prevent the increase of the program code capacity in this processing system and to select the optimum method definition in accordance with the state of a method call instruction. Then the method calling speed is increased, that is, the executing speed of an object-based program is increased.

Description

[Detailed Description of the Invention] [Summary] This invention relates to an efficient method execution processing method in an object-oriented program processing system.

Prevent the explosive increase in the amount of code for method definitions.

The purpose is to enable high-speed search for method definitions that should actually be executed even if method definition descriptions are shared between objects.

Each class is configured with class identification information, a method definition, and method selection information for selecting a method definition, and when an object is created, method selection information is collected from each class that makes up the object and is duplicated. , and configures the object with the information for each object a and the method selection information organized above, and when a method is called for the object during program execution, the method selection information for the object is referred to and the method definition is retrieved. It was configured to do this.

[Industrial application field]

The present invention relates to an efficient method execution processing method in an object-oriented program processing system.

In recent years, programming style, program componentization,
Object-oriented languages are attracting attention because of their affinity with knowledge representation.

Generally, an object-oriented program is a collection of "objects" made up of a plurality of "classes", as conceptually shown in FIG.

Within each class, processing descriptions called "methods" are defined. In other words, an object has the ability to execute (perform processing) methods defined in multiple classes that constitute the object.

Prior to execution of an object-oriented program.

Define a class and write method definitions in it, and generate an object from an appropriate class just before or during execution. Program execution progresses by calling methods on objects and performing the processing defined there.

Within an object, method invocation instructions are received and based on the inheritance rules of the class.

The receiver searches for a definition that matches the received method call instruction and processes it. The selection of method definition may also be influenced by the value, type 9, etc. of the argument accompanying the method call instruction.

Large-scale object-oriented programs such as expert systems began to be developed.

The classes and methods that make up objects are becoming more diverse.
It is becoming mass-produced. In order to execute such a large-scale object-oriented program at high speed, it is necessary to quickly search for method processing within an object, particularly a method definition corresponding to a method call instruction, and perform the processing.

[Conventional technology]

In conventional object-oriented language processing systems, there are roughly two methods for processing method calls.

fa+ A method of copying (incorporating) all method definition codes of all the classes that make up the object into the object.

A method in which an object contains a correspondence table between a list of 7 method names and the location (class) where they are defined, called a bl r method module.

In method (4), since the object itself has a processing description, there is no need to search for each class to see if there is a method definition description.

However, in cases where an object consists of a large number of classes, or where the same class is shared between multiple objects (for example, objects A and 8 in Figure 8), the amount of definition code becomes enormous. It ends up.

Also, (with the bl method, even if multiple objects share a class, the amount of code does not increase much. However, this method module 1...

There is simply information about "which class defines which memory processing description."

Therefore, if methods of the same format are defined in multiple classes within one object.

It searches the method module, finds the corresponding method, and executes each method in turn.

A specific example of the method of the prior art 0)) will be explained first with reference to FIGS. 9 and 10.

Figure 9 is an example of an object-oriented program, and asks a question [goal] about object A defined by classes a, b, and c. -: Finds a solution that satisfies method-1 (Obj, 3).

Class a has two method definitions containing arguments "1" and "-1", respectively, in parentheses after the predicate rmethod -I J, and class b has two method definitions containing arguments "1" and "-1", respectively.
class C has three method definitions, and class C has three method definitions.
” has one method/end definition.

In FIG. 10, processing steps in the case of processing the program in FIG. 9 using the method of the prior art (b) are indicated by ■ to ■. As shown in the figure, a method module is set in object A that has a list of method names and information indicating the class in which the methods are defined.

When a method call command) is issued (■).

See the first entry in the object module.■
), first find the method definition location of class a (■),
Access the method definition of class a and perform unification processing (■). The question is not satisfied here. Next, refer to the next entry in the object module (■), find the method definition location of class b (■),
Perform unification processing on the method definition of class b, the question is not satisfied here either, then please refer to the following entry in the object module ■)
, find the method definition location of class C (■), and find the method definition location of class C
We perform unification processing on the method definition of , and here we obtain a solution that satisfies the question.

By the way, methods are often defined in such a way that they check the arguments passed to them, and if the check is satisfied, they perform the original processing.

In the method (al), all method definitions in 2 are collected in one place, so it is possible to quickly find a desired method definition by optimization such as indexing based on argument values, types, etc. However.

In method Cb), such optimization is impossible because method definitions are separated for each class.

[Problem to be solved by the invention]

Conventional technology 1al, which incorporates definition codes of all methods into an object, can speed up method execution, but in the case of large-scale programs, the amount of definition code to be written increases explosively. This has the disadvantage that memory usage efficiency decreases due to the sharing of duplicate definition codes between objects.

In addition, the method of conventional technology (b), which has only a "method module" in the object and accesses the actual method definition location, has good memory usage efficiency, but the state of the method call instruction (for example, the argument It is not possible to select method definitions based on distinctions (value, type, etc.), and each method definition must be executed in sequence, which has the drawback of not being able to speed up method execution.

An object of the present invention is to prevent an explosive increase in the amount of code for method definitions, and to enable high-speed search for method definitions to be actually executed even if method definition descriptions are shared among objects.

Instead of including a copy of the method definition code for every class in an object, the present invention provides method selection that includes a pointer to where the actual method definition code resides and related information that serves as an index for searching the method definition code. It allows objects to hold information.

This method selection information includes not only a pointer directly pointing to the location where the method definition code exists, but also related information such as the value of the argument of the method definition and the type of the argument value (constant, struct, etc.). This makes it possible to select a valid method definition using only this relevant information without having to access the actual method definition code.

FIG. 1 is an explanatory diagram of the principle of the present invention.

In fig.

1-1 to 1-n are classes constituting the object to be generated, and each includes class identification information,
It consists of an arbitrary number of method definitions and method selection information consisting of a pair of relevant information and pointers useful for selecting each method definition.

Step 2 is the object generation stage, in which method selection information is collected from each of classes 1-1 to 1-n, and when methods are defined in the same format between classes, the method selection information is combined into one. Organize and integrate.

3 is a generated object, which has object identification information and integrated method selection information.

Step 4 is the program execution stage. When a method call request is made, if there is a method that matches the requested method format, the method selection information is searched for a method whose related information matches, and a matching method is found. If there is something to do, call and execute the method definition of the class pointed to by the pointer paired with the related information.

[For production]

In the present invention, three pieces of selection information are prepared for each method of the same format in each class, as shown in Figure 2.0. This selection information stores related information for selecting one method and a pointer to the location of the corresponding method definition.

When an object is created, the selection information of all the methods of the classes that make up this object is extracted and the object has it. At this time, data were collected from multiple classes. Selection information for methods of the same format is integrated to become one selection information.

Thus, a method call issued to an object first looks for selection information for a method of the same type. Then, depending on the state of the method call instruction, the address to the corresponding method definition description can be obtained from the selection information, and the code of the method can be directly executed.

Also, in object-oriented languages, there is an "instance"
There is a collection of classes that are created dynamically during program execution, separate from objects. For this as well, a method call is issued in the same way as for objects, and method selection processing is performed.

The difference between an object and an instance is whether they are statically generated before program execution or dynamically generated during program execution, and the processing of internal method calls is the same.

This 5 method call process in the instance is also 1
It is possible to apply the present invention.

〔Example〕

The present invention will be described in detail below with reference to FIGS. 2 to 7.

Figures 2 and 3 show the internal structures of classes and objects, respectively.

In fig.

11 indicates a class.

Reference numeral 12 is method selection information, which is prepared for each method with the same name and is a correspondence table between information for selecting a method to be executed when a method call instruction is executed and information on the location where the definition exists. .

13 is a method definition.

14 is a class identification information area in which class names and the like are stored.

15 is a method selection information area in which method selection information is stored.

16 is a method definition area in which method definitions are stored.

In fig.

17 indicates an object.

18 is generated from the selection information group of the class that covers the object when the object is generated. This is method selection information for the object.

19 is an object identification information area in which object name 1 and the like are stored.

20 is a method selection information area in which method selection information is stored.

FIG. 4 is a flowchart showing the procedure for generating an object.

In preprocessing, define or set the class and method, specify the class that will contain the object to be generated, and obtain a class list.Next, collect method selection information from each of those classes and create the object. Create method selection information.

Perform necessary editing in post-processing to generate an object with a defined internal structure.

FIG. 5 is a flowchart showing the procedure of method calling processing.

When a method is called, the format of the requested method is checked to see if there is a method with the same format. If there is no matching question, the question will fail.

If there is, then check the state S (condition) of the calling command, search for method selection information based on it, and if there is no matching information, the query will fail, and if it exists, the address of the place where the method definition is written. Get (pointer). Method definition processing based on that address (unification 3)
If it fails, search for other method selection information and repeat the same procedure until the process is completed twice.

FIG. 6 exemplarily shows the overall internal structure of each object and class after object generation.

In the illustrated example, object A has classes a and b.
Object B is composed of class b and class C. Class b is shared by object A and object B.

Class a has method format r method -I
Definition of J and method format r method -2 Definition of J is described, and class b also has method format r method
Definitions of d −I J and r+ethod 2 J are described.

In class C, definitions of method formats rmethod -1 and rmethod 3 J are described. Method selection information for each method definition is set for each class a, b, and c.

Object A and Object B are set with method selection information collected from the classes of their respective constituent elements, so that the corresponding method definitions can be directly referenced, as shown by the arrows in Figure 9.

FIG. 7 shows a specific example of method calling processing when object A and classes a, b, and c are used in the program example shown in FIG. 9.

First, when generating an object, method selection information for the object in (d) is created by collecting and integrating memory selection information in (a) to (C).

Normally, when a method call is issued to an object (■), selection information for the corresponding method is obtained from the format of the method to be called (■).

method argument value) is checked (■>.

Based on the result, obtain the address of the corresponding method definition (■>. Then, process the description of the obtained definition (
■).

In the above example, the value of the argument in the method definition is used as the method selection information, but this does not have to be the value of the argument and may indicate the range of possible values of the two arguments.

Furthermore, the type of argument value (constant, structure 9, etc.) may be used as method selection information.

〔Effect of the invention〕

As explained above, according to the present invention, it is possible to prevent an increase in program code capacity within a processing system, and to select an optimal method definition depending on the state of a method call instruction.
It greatly contributes to speeding up method call processing, that is, speeding up the execution of object-oriented programs.

[Brief explanation of drawings]

Fig. 1 is an explanatory diagram of the principle of the present invention, Figs. 2 to 7 are explanatory diagrams of embodiments of the present invention, Fig. 2 is an explanatory diagram of the internal structure of a class, and Fig. 3 is an explanatory diagram of the internal structure of an object. 4 is a flowchart of object 1 processing, and FIG. 5 is a flowchart of method call processing. FIG. 6 is the overall internal configuration after object generation. FIG. 7 is an explanatory diagram of a specific example of method call processing. FIG. 8 is a conceptual diagram of an object-oriented program.5 FIG. 9 is an explanatory diagram of an example of an object-oriented program. Figure 1O is the conventional technology-)
FIG. 1-1 to 1-n in Figure 1: Class 2: Object generation stage 3: Object 4 Niprogram execution stage

Claims (1)

[Claims] In an object-oriented program processing system, method selection information is provided for each class, including class identification information, method definition, related information useful for selecting the method definition, and a pointer pointing to the method definition location. When an object is generated, method selection information is collected from each class that constitutes the object, duplicates are sorted out, the object is configured from the object identification information and the sorted method selection information, and the program An object-oriented program execution processing method characterized in that when a method of an object is called during execution, method selection information of the object is referred to and a method definition is retrieved.