JPH10207709A - Method for sharing object - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a method for sharing an object so that the object can be shared between processes by generating the same object for another object by packet transmission or using a shared memory. SOLUTION: A transmission process generates an object, and then transmits the class name, instance name, and object main body of the object to a receiving process as a packet P, and the receiving process generates an object having the same class name, instance name, and object main body as the received packet, and shares the object. The transmitting process arranges the generated object on a shared memory, and the receiving process receives the class name, instance name, and object address as the packet P, and shared the object on the share memory.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method for sharing objects between processes in computer software using an object-oriented programming technique.

[0002]

2. Description of the Related Art In object-oriented technology in computer software, classes and instances are designed to realize a target process function. A class is an object that defines a superordinate concept of an object, and an instance is defined as a concrete substance of the class. Hereinafter, a class object and an instance object are collectively called an object.

In one world, all objects are located in the same space and look the same from all objects, such as class inheritance and relationships between objects.

Further, it is possible to call a procedure (hereinafter referred to as a method) of the generated object.

[0005]

Software using conventional object-oriented programming techniques is designed such that all classes and objects are limited to a single thread and process. For this reason, it is not possible to cope with the case where the creation of an object is designed across threads, processes, and networks.

FIG. 3 shows a computer system connected to a network by multi-threading and multi-processing. Each of the processes P1 to PN has a unique address space for each process in the computer, and a memory for the other processes. Do not share. The thread S shares the address space of the process, but the processing unit is independent of the process.

In this system configuration, the handling of objects of each process is limited to the process to which the process belongs, so that the following functions are limited between objects.

(1) The class definition cannot be propagated. Class inheritance and relationship cannot be propagated. (2) Instance generation cannot be propagated. Objects cannot be shared (3) Method calls cannot be propagated. An object of the present invention is to provide an object sharing method that enables an object to be shared between processes.

[0009]

SUMMARY OF THE INVENTION The present invention provides a method for sharing an object between processes using a method of generating the same object for another object by packet transmission of an object generated by one process, or using a shared memory. A method for sharing objects between processes, characterized by the following method.

(First Invention) In sharing an object between processes in computer software using object-oriented programming technology, when a certain process generates an object, a class name, an instance name, and an object body of the object are changed. The packet is transmitted to another process, and the other process generates an object having the same class name, instance name, and object body as the received packet, and shares the object.

(Second Invention) In sharing an object between processes in computer software using object-oriented programming technology, it is possible for an entity generated by a certain process to see an object of an instance in a process space of a plurality of processes. Placed on a shared memory where the class name, instance name, and object address of the generated object are transmitted to another process by packet transmission, and the other process uses the same class name, instance name, and object address as the received packet. The object on the shared memory is shared.

[0012]

BEST MODE FOR CARRYING OUT THE INVENTION

(First Embodiment) FIG. 1 shows an embodiment of the present invention.
This is a case where objects are independently shared between one computer or two processes across a network in FIG.

In FIG. 1, when the receiving process shares the instance object possessed by the transmitting process, the transmitting process and the receiving process respectively hold class information in tables 1S and 1R having a list structure. The class information includes a class name, a pointer of a method for generating an instance (a constructor pointer), and an instance list. As a premise, the same class definition is referred to in the sending / receiving process, and the instance information is held in the tables 2S and 2R of the list structure.

A class constructor pointer table is generated by a necessary process, and class definition information is added to the tables 1S and 1R in advance. The initial instance list is empty.

When an instance created in the sending process is sent to the receiving process, when the sending process specifies and creates a class name, the class constructor pointer table 1S is searched by the class name, and the constructor of the matched class information is called. Class instance 3
Generate S. When an instance is generated, it is added to the instance list 2S and registered. At the same time, the packet P is transmitted to the receiving process that should share the instance. The virtual function table 4 is used for packet transmission and reception.
S, 4R are prepared.

As the packet P, the class name, the instance name, and the object body are transmitted. The receiving process that has received the packet reproduces the same object as the object in the process. This extracts the class name from the packet and stores the class constructor pointer table 1R
And calls a constructor with the instance name in the packet to generate an instance 3R. Further, the instance body in the packet is copied to the generated instance.

In the present embodiment, the sharing of the object between the transmitting and receiving processes is a method of copying the instance generated in the transmitting process as a packet in the receiving process, and can be realized even if the process is over a network.

Further, since the number of processes is not limited,
It can handle large multi-process applications.

(Second Embodiment) In the first embodiment, a copy of an object can be shared between a plurality of processes by transmitting an instance body to create a copy of the object. In this case, since a plurality of the same objects are created, in consideration of the identity and synchronization of the objects, it may be effective to use only one object.

Therefore, the present embodiment provides a method for sharing an object between processes as the only object.

FIG. 2 shows an object sharing method according to the present embodiment. Like FIG. 1, it has class / constructor pointer tables 1S, 1R and holds class information.
The feature of this method is that the entity of the instance is arranged on the shared memory M which can be seen in the process space of a plurality of processes. By arranging on the shared memory, the instance becomes only one entity.

In the generation procedure, a class constructor pointer table 1S is searched using a class name to be generated as a key in the transmission process as in the first embodiment, and a constructor is called with a specified instance name to generate an instance. The instance is generated on the shared memory M.

When an instance is generated, it is added to the instance list 2S. At the same time, the packet P is transmitted to the receiving process that should share the instance. As the packet P, a class name, an instance name, and an object address are transmitted. The process that has received the packet acquires the class information using the class name of the packet as a key, adds the object address to the instance list 2R, and points to the instance on the shared memory.

In the present embodiment, a plurality of processes share an object of the same substance, so that memory resources and the like can be reduced, and there is no need to transmit / receive information between objects. It becomes possible.

[0025]

As described above, according to the present invention, an object generated in a certain process is generated in the other object by packet transmission, or the object is shared between processes using a shared memory. Therefore, even when the handling of the object of each process is limited to the process to which the process belongs, the object can be shared by the propagation of the class definition, the propagation of the class inheritance relationship, the propagation of the generation of the instance, the propagation of the method call, and the like.

[Brief description of the drawings]

FIG. 1 illustrates a method of independently sharing objects in a process according to an embodiment of the present invention.

FIG. 2 illustrates a method of sharing objects between processes according to another embodiment of the present invention.

FIG. 3 is a diagram showing the relationship among threads, processes, and networks in object-oriented programming.

[Explanation of symbols]

 P1, P2, PN: Process S: Thread 1S, 1R: Class / constructor pointer table 2S, 2R: Instance table 3S, 3R: Instance 4S, 4R: Virtual function table P: Packet M: Shared memory

Claims (2)

[Claims] Claims 1. In sharing an object between processes in computer software using object-oriented programming technology, when a process generates an object, the class name and instance name of the object and the object body are transmitted by packet transmission to another process. And an other process generates an object having the same class name, instance name, and object body as the received packet and shares the object. 2. In sharing an object between processes in computer software using object-oriented programming technology, an object generated by a certain process is placed on a shared memory in which an entity of the instance can be seen in a process space of a plurality of processes. And sends the generated object's class name, instance name, and object address to another process by packet transmission. The other process uses the same class name, instance name, and object address as the received packet on the shared memory. An object sharing method, characterized by sharing an object.