JPH0520082A - Execution system of object-oriented language - Google Patents

Abstract

(57) [Summary] [Purpose] To realize high-speed binding between a message as a processing request and a method as a processing procedure corresponding to this. [Configuration] One method table 11 is provided for each class. The method table 11 includes a plurality of methods 1
Each address of 6 is stored as a method address. The displacement representing the storage position of each method address in the method table 11 is determined in advance at the time of compilation as a constant corresponding to the type of message. 1 of 16 methods
An object 13 that receives a message of the type to be processed by one has a pointer 14 for pointing to the address of the method table 11. The address of the method corresponding to the message received by the object 13 of the plurality of methods 16 is obtained from the method table 11 according to the pointer 14 and the displacement of each message.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an object oriented language execution system.

[0002]

2. Description of the Related Art First, in explaining the prior art,
The necessary points of the object-oriented language targeted by the present invention will be briefly described.

In the object-oriented language, processing proceeds in the form of sending a processing request to the structural data on the memory. This structural data is called an object, and the processing request is called a message. Similarly, the plurality of objects generated in the memory each belong to one of the classes.
A processing procedure (called a method) for processing one type of message received by the object at one time is defined in the memory for each class. A message of the same type received by an object as an instance of a class is processed through execution of a method corresponding to the message in the class to which the object belongs.

The process of associating a method to be executed with a certain message (this is called binding) is one of the important processes, and the processing speed of the binding is the same as that of the entire execution system of the object-oriented language. It is a factor that affects the speed. That is, it is necessary to realize high-speed binding for high-speed execution of an object-oriented language. There is also an object generation method for generating a new object belonging to the class on the memory in response to a message for the class.

Another important function of the object-oriented language is inheritance of methods between classes. Method inheritance means that when a certain class is created, it inherits the method defined for another specified class (this is called a superclass) and the inherited method is called that class (this is called a subclass). .) Method. However, it is also possible to redefine a new method in the subclass without using the inherited method. To redefine means to inherit a method for a message and then define another method as a method for the message in a subclass.

For example, if the method M corresponding to the message m is defined in the class A and the class A is designated as the superclass when the class B is created,
The message m sent to the object b belonging to the class B will be processed by the method M defined in the class A. However, when the method MM is redefined in the class B as the method corresponding to the message m, the message m sent to the object b belonging to the class B is processed by the method MM defined in the class B. It will be. However, even in this case, class A
The message m sent to the object a belonging to is processed by the method M defined in the class A.

As described above, in an object-oriented language execution system, which method a message sent to an object is bound to must be dynamically determined according to which class the object belongs to. .

Then, the conventional binding method will be specifically described with reference to FIGS. 5 and 6.
A message usually has a message identifier for identifying between messages and an argument associated with it. conventionally,
One message method correspondence table is created in advance for each class on the memory. When a message is sent to an object, search the message method correspondence table using the message identifier in the message as a key. Has determined the corresponding method. This realized the binding between the sent message and the corresponding method.

FIG. 5 is a conceptual diagram showing the structure of a conventional object-oriented language execution system, and FIG. 6 is a flow chart showing the procedure of binding messages and methods in the execution system.

In FIG. 5, reference numeral 51 is class information relating to a certain class, and 52 is a pointer to the class information 60 of the superclass designated for the class. 53 is a message method correspondence table,
Addresses (pointers to methods) of multiple methods 59 defined for each message type in this class 5
5 and the message identifier 54 of the message processed by each method are stored in the form of a pair. Also, 5
6 is one object belonging to this class, 57 is a pointer for pointing the address of the class information 51, 5
Reference numeral 8 is a storage area for the data of the object 56.

When a certain type of message is sent to the object 56, first, as shown in FIG. 6, a pointer 57 pointing from the object 56 to the class information 51 is obtained (step ST61). Next, the message method correspondence table 53 is obtained from the class information 51 pointed to by the pointer 57, and among the plurality of message identifiers 54 in the table 53, there is one that matches the message identifier of the transmitted message. It is searched whether or not (step ST62). Subsequently, it is determined whether or not the matching message identifier 54 is found in the message method correspondence table 53 (step ST63). If the message identifier 54 is found, the address 55 of the method 59 corresponding to the message is set. Obtained from the message method correspondence table 53 (step S
T64). If not found, a pointer 52 to the class information 60 of the superclass in the same class information 51 is obtained (step ST65), and step ST62 and subsequent steps are repeated based on the pointer 52 to the class information. That is, the message method correspondence table for the superclass is further searched.

[0012]

The above-described conventional object-oriented language execution system handles message methods in which a plurality of pairs of message identifiers 54 and method addresses 55 are stored for binding between messages and methods. The table 53 is provided for each class, and it is necessary to search the message method correspondence table 53 each time a message is sent to an object at the time of execution. Therefore, there is a problem that the memory occupation area of the class information 51 becomes large and a lot of time is required for binding.

In particular, the object 5 belonging to the subclass
When binding the message sent to the method 6 to the method inherited from the superclass, it is necessary to search the table a plurality of times, which causes a problem that the binding time becomes very long.

An object of the present invention is to reduce the capacity of a table for each class and to realize high-speed binding between a message and a method.

[0015]

In order to achieve the above object, the present invention adopts a structure of a method table in which a method address without a message identifier is stored and represents a storage position of each method address. The configuration is such that the displacement is determined in advance as a constant according to the type of message at the time of compiling.

Specifically, the invention of claim 1 is as follows.
A plurality of methods respectively defined at different addresses on a memory for one class as an executable processing procedure corresponding to each of a plurality of types of messages as processing requests, and on the memory for the class. In the above, the displacements that are created at different addresses from the plurality of methods, the addresses on the memory of each of the plurality of methods are respectively stored as method addresses, and the displacement indicating the storage location of each method address is the message of the plurality of types. A method table predetermined at the time of compilation as a constant corresponding to each of the methods, and a plurality of methods and method tables generated at different addresses in the memory for the class and in the memory of the method table. address And it has a pointer for indicating in which a configuration in which a object to receive one of the plurality of types of messages employing a time. Then, the message received by the object is bound to the method corresponding to the message through the method address corresponding to the message in the method table according to the pointer and the displacement as a constant for each type of the message, In addition, processing is performed through the execution of the bound method.

The invention according to claim 2 further comprises the plurality of methods, the method table and the object for each of the plurality of classes, and a method table for one of the plurality of classes and other methods. The method table for one class has a configuration in which the same method address is stored at the position represented by the same displacement for inheriting the method between both classes.

The invention according to claim 3 is further provided with the plurality of methods, the method table and the object for each of the plurality of classes, and a method table for one of the plurality of classes and other methods. The method table for one class is configured such that different method addresses are stored at the positions represented by the same displacement.

According to a fourth aspect of the invention, the method table created for the one class is an area to be secured on the memory in order to occupy an object newly created for the class. Is further stored.

[0020]

According to the invention of claim 1, when a message of a certain type is sent to an object, the address in the pointer of the object and the displacement as a constant for the message are simply added, The method address corresponding to the message can be immediately obtained without searching the method table, and the message and the method are bound through the method address. Moreover, since the method address in the method table does not need to be accompanied by the message identifier, the memory occupation area of the method table becomes smaller than that of the conventional message method correspondence table.

According to the invention of claim 2, the method table for one class as a superclass and the method table for another class as a subclass are represented by the same displacement. Since the same method address is stored in each position, the inheritance of the method between both classes is realized through the same method address. That is, since the address of the method to be inherited between both classes is stored in the same position represented by the common displacement in both method tables, for example, the message m sent to the object a belonging to the superclass is the method M. When bound to the same method, the same message m sent to the object b belonging to the subclass is also bound to the same method M. Moreover, even if there is a method inheritance between classes in this way, just as with the case where the method does not inherit, by simply adding the address in the pointer of the object and the displacement as a constant for the message, the method table The required method address can be immediately obtained without performing a search.

According to the invention of claim 3, the method table for one class as a superclass and the method table for another class as a subclass are represented by the same displacement. Different method addresses are stored in the respective positions, and it is possible to correspond to the redefinition of the above method. For example, when the method M is defined as the method corresponding to the message m in the superclass, and the method MM is redefined as the method corresponding to the same message m in the subclass, it is sent to the object a belonging to the superclass. Message m is bound to method M, whereas the same message m sent to object b belonging to its subclass
Will be bound to different methods MM.

According to the fourth aspect of the invention, in addition to each method address, the size of the memory occupied area required for generating a new object is stored in the method table for each class. . In response to a message for a class, in order to trigger the execution of the above-described object creation method for creating a new object belonging to that class in memory, the address of the table in which the method address is stored is created for that object. It is necessary to pass not only the method to the method but also the size of the object to be created to the object creating method. However, according to the invention of claim 4,
Since the required size of the object is stored in the method table, set the address of the method table to 1
It only needs to be passed as one argument to the object generation method, and the processing time of the argument by the object generation method can be shortened. Moreover, the object creation method that received the address of the method table allocates an area of the required size in memory for the object to be created, and then uses the pointer to the method table provided in that area. By writing the address of the method table previously received as an argument, a new object associated with the method table can be generated. As a result, even for the new object, high-speed binding between the message and the method can be secured.

[0024]

Embodiments of the present invention will now be described in detail with reference to the drawings.

FIG. 1 is a conceptual diagram showing a configuration of an object oriented language execution system according to an embodiment of the present invention, and FIG. 2 shows a procedure of binding between a message and a method in the execution system. It is a flowchart figure.

In FIG. 1, 11 is a method table for a certain class, and 12 is a pointer to each of a plurality of methods 16 defined for each message type in this class (each method address is stored). ). Further, 13 is one object belonging to this class, 14 is a pointer for pointing the address of the method table 11, and 15 is a data storage area of the object 13.

When there is a method inheritance between classes, the method table 11 shows that the addresses of the methods 16 inherited from the superclass to this class (subclass) are arranged first, and then the methods 16 additionally defined in the subclass are listed. It is created on the memory so that the addresses are lined up. That is, the method table 11 of this class
In the method table of the superclass designated for the class, the same method address for the inherited common method 16 is stored at the same position in each table. However, regarding the method 16 redefined in the subclass, the method 16 redefined in the subclass without changing the order of the addresses of the inherited methods in the method table 11.
Will be replaced with the address of.

As described above, this method table 11
The displacement indicating the storage position of each method address within the message, that is, the numerical value indicating the number of the method address stored in the method table 11 to be accessed for a certain message is the message corresponding to each method 16. Is a constant corresponding to each of the types, and is determined in advance when compiling. In particular for inherited methods, the same displacement can be used in superclasses and subclasses.

Now, when a certain type of message is sent to the object 13, as shown in FIG. 2, first, the address of the method table 11 from the pointer 14 in the object 13 (the storage position of the first method address)
Is obtained (step ST21). The address of the method 16 to be bound to the message received by the object 13 is stored in the method table 11 at a position represented by a constant displacement according to the type of the message. The corresponding method address is immediately obtained without searching 11 (step ST22). That is, the method 16 to be executed can be immediately specified through the pointer 12 to the method 16 having the method address as the content.

As described above, according to the present embodiment, it is possible to realize the binding between the message and the method by referring to the pointers 14 and 12 only twice without performing a table search that requires a lot of time. The time will be very short. In addition, the fact that binding can be realized by referring to the pointer only twice is the same as in the case of the inherited method, and the binding time is greatly shortened compared to the case where the table search is required multiple times in the past. be able to. Moreover, since each method address in the method table 11 need not be accompanied by a message identifier, the capacity of the method table 11 should be halved compared to the conventional message method correspondence table (53 in FIG. 5). You can

Next, the above embodiment will be described more specifically. FIG. 3 is a conceptual diagram showing a configuration in which the configuration of FIG. 1 is embodied for two classes A and B. However, class B
Is a subclass whose class A is a superclass.

In FIG. 3, 31 is a method table of class A, 32 is one object belonging to class A, 33 is a method table of class B, and 34 is one object belonging to class B. Also, 35 is
Two methods defined for class A,
Method M is a method for processing message m,
Method N is a method for processing the message n. 36 is a method defined for the class B. However, class B with class A as a super class
Does not directly inherit the methods M and N from the class A, but redefines the method corresponding to the message m in the method MM, and additionally defines the method T for processing the message t. .

First, the procedure of creating the method tables 31 and 33 performed by the compiler or the like will be briefly described with reference to FIG.

The method table is created in order from the upper class in the class hierarchy. That is, in FIG. 3, the method table 31 of the class A, which is a superclass of the class B, is created first. Since the method M and the method N are defined as executable methods in the class A, the method table 31 in which the addresses of the method M and the method N are stored is created.
At this time, the storage position of each address of the method corresponding to each message in the method table 31, that is, the displacement in the method table 31, is determined as a constant. In the case of FIG. 3, the method M corresponding to the message m in the class A is determined to be the first method in the method table 31, and the method N corresponding to the message n is the second method. It is decided.

Next, a method table of another class whose super class is a class for which a method table has already been created is created. That is, in FIG. 3, the method table 33 of the class B having the class A as a super class is created. There, first, the method table 31 of the superclass A is copied and the prototype of the method table 33 of the class B is created. As a result, method inheritance, which is one of the important functions of object-oriented languages, is realized. Then, the address of the method MM corresponding to the message m redefined by the class B is set to the position corresponding to the message m in the method table 33, that is, 1
Store th. Then, the address of the method T corresponding to the message t newly defined in the class B is additionally stored in the method table 33. At this time, the method T corresponding to the message t is 3 in the method table 33.
Determined to be th.

By repeating the above procedure, method tables for all classes are created. As a result, in the example of FIG. 3, the order of the method addresses in the method table 33 of the class B, which is a subclass of the class A, is such that the method M of the class A corresponding to the message m is first redefined.
The address of the method MM corresponding to the message is aligned with the address of the method N inherited from the class A so as to correspond to the message n, and then the address of the newly defined method T enters. . That is, when the method tables 31 and 33 are viewed from the side of the objects 32 and 34, the position corresponding to the message m is the first position, and the position corresponding to the message n is the second position. The position corresponding to the message t is the third position. In this way, the displacements in both the method tables 31 and 33 are uniquely determined in advance at the time of compilation for each message type, regardless of the difference between the object and the class.

In the example of FIG. 3 described above, when the message m is sent to the object 32 belonging to the class A, the method M indicated by the first method address of the method table 31 of the class A is the message. m
Bound to. On the other hand, when the message m is sent to the object 34 belonging to the class B, the method MM indicated by the first method address in the method table 33 of the class B is bound to the message m. On the other hand, when the message n is sent to the object 32 belonging to the class A, the method N is also bound to the message n when the message n is sent to the object 34 belonging to the class B. When the message t is sent to the object 34 belonging to the class B, the method T
Is bound to the message t. As described above, according to the example of FIG. 3, it is possible to realize a function of inheriting a method between classes and a dynamic binding between a message and a method.

Next, another embodiment of the present invention will be described with reference to the drawings.

FIG. 4 is a conceptual diagram showing the configuration of an object oriented language execution system according to another embodiment of the present invention. In the figure, 41 is a method table having an area 42 for storing the size of the object 13 at the head. One such method table 41 is created for all classes. In the head area 42 of the method table 41 for each class, the size of the area to be secured in the memory in order to be occupied by the new object 13 when the new object 13 belonging to the class is generated It is stored in advance. The method table 41 has a structure in which the pointers 12 to the respective methods 16 are arranged after the storage area 42 of the size of this object, as in the case of FIG.

Moreover, in the method table 41 for any class, the size of the object size storage area 42 is constant, and the displacement indicating the storage location of each method address is the same as in the case of FIG. In comparison, the bias is given only for the fixed size of the region 42. Therefore, the displacement related to each method address in the method table 41 is uniquely determined at compile time for each message type regardless of the difference between the object and the class, and the high-speed binding between the message and the method can be realized. The same as in the case of the previous embodiment shown in FIG.

Now, in order to generate a new object belonging to the class on the memory in response to the message for the class, the object generation method must be activated. Then, at the time of this activation, not only the address of the table storing the method address but also the size of the object to be generated needs to be transferred to the object generating method. Therefore, in the case of the previous embodiment shown in FIG. 1, the method table 1 is added to the object generation method for generating the object 13.
Not only is the address of 1 passed as one argument, but the size of the object 13 to be generated is passed as another argument. However, according to the present embodiment shown in FIG. 4, since the required size of the object 13 is stored in the method table 41, the address of the method table 41 is passed as one argument to the object generation method. The processing time of the argument by the object generation method can be shortened. In other words, the object generation method can be started at high speed. Generally, in a program written in an object-oriented language, objects are frequently created, so the execution speed of the entire program can be greatly improved by speeding up the activation of the object creation method.

The object generation method that has received the address of the method table 41 in this way allocates the object 13 to be generated to a certain memory area according to the contents of the object size storage area 42, and then allocates that memory area. The new object 13 associated with the method table 41 is generated by writing the address of the method table 41 previously received as an argument into the pointer 14 therein. As a result, also for the new object 13, high-speed binding between the message and the method through the two pointers 14 and 12 can be secured.

[0043]

As described above, according to the first aspect of the present invention, the displacement indicating the storage position of each method address in the method table for each class is set as a constant according to the type of message in advance at the time of compilation. Since the configuration is decided beforehand, the object can be received without searching the method table based only on the pointer that points to the address of the method table in the object and the displacement as a constant for each type of message. It is possible to quickly bind the message to the method. Moreover, unlike the conventional method, the method address in the method table does not need to be accompanied by a message identifier for retrieval, so that the capacity of the method table on the memory can be reduced as compared with the conventional method.

Further, according to the second aspect of the invention, the method table for each of the two classes adopts a configuration in which the same method address is stored in the position represented by the same displacement. Method inheritance can be realized between both classes through the same method address, and at the same time, high-speed binding between message and method can be realized.

According to the third aspect of the present invention, the method table for each of the two classes has a structure in which different method addresses are stored at the positions represented by the same displacement. It can support dynamic binding, including redefinition.

Further, according to the invention of claim 4, in addition to each method address, the memory size required for generating a new object is further stored in the method table. It is only necessary to pass the address of the table as an argument to the object generation method, the processing time of the argument by the object generation method can be shortened, and the object generation method is provided with a new fast binding between the message and the method. Objects can be generated at high speed.

[Brief description of drawings]

FIG. 1 is a conceptual diagram showing the configuration of an object oriented language execution system according to an embodiment of the present invention.

FIG. 2 is a flowchart showing a procedure of binding between a message and a method in the object oriented language execution system of FIG.

FIG. 3 is a conceptual diagram showing a configuration in which the configuration of FIG. 1 is embodied for two classes.

FIG. 4 is a conceptual diagram showing the configuration of an object oriented language execution system according to another embodiment of the present invention.

FIG. 5 is a conceptual diagram showing a configuration of a conventional object-oriented language execution system.

6 is a flowchart showing a procedure of binding between a message and a method in the object oriented language execution system of FIG.

[Explanation of symbols]

11, 31, 33, 41 Method table 12 Pointer to method 13, 32, 34 Object 14 Pointer to method table 16, 35, 36 Method 42 Object size storage area

Claims (4)

[Claims] 1. A plurality of methods defined as different addresses in a memory for one class as an executable processing procedure corresponding to each of a plurality of types of messages as processing requests, and the class. Is created at a different address from the plurality of methods on the memory, and the addresses on the memory of each of the plurality of methods are stored as method addresses, respectively, and a display representing the storage location of each method address is displayed. Method is predetermined at the time of compilation as a constant corresponding to each of the plurality of types of messages, and the plurality of methods and method table in the memory for the class is generated at a different address, And the method table An object having a pointer for indicating an address in memory and receiving one of the plurality of types of messages at a time, wherein the message received by the object is the pointer and the type of the message. According to the displacement as a constant for each, the method is bound to the method corresponding to the message through the method address corresponding to the message in the method table, and is processed through the execution of the bound method. Object-oriented language execution system. 2. A plurality of methods, a method table, and an object for each of a plurality of classes, respectively, a method table for one of the plurality of classes, and a method table for another one of the plurality of classes. 2. The object table according to claim 1, wherein the method table has the same method address stored at the position indicated by the same displacement for inheriting the method between both classes. Execution system. 3. A plurality of methods, a method table, and an object for each of a plurality of classes, respectively, a method table for one of the plurality of classes, and a method table for another one of the plurality of classes. The object-oriented language execution system according to claim 1, wherein different method addresses are stored in positions represented by the same displacement as the method table. 4. The method table created for the one class further stores the size of the area to be reserved on the memory in order to occupy an object newly created for the class. The object-oriented language execution system according to claim 1, characterized in that: