JPH10275082A - System and method for remote object access - Google Patents

Abstract

PROBLEM TO BE SOLVED: To dynamically generate an object on a computer across a network by making use of a remote procedure(RPC) and to access it. SOLUTION: A client computer 11 has a main program 3 and a conversion logic client stub 8. A server computer 12 has a conversion logic server library 9. In response to a generation request from the main program 3, the server library 9 generates an object 2, assign a unique object ID thereto, and stores this object ID and a pointer into a correspondence table 10 and also returns the object ID to the main program 3. Then, the main program 3 specifies the object ID and issues a process request and a deletion request to the object 2. The server library 9 acquires the pointer corresponding to the object ID from the correspondence table 10 and processes the object 2 that the pointer 2 indicates.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a remote object access for operating an object on another computer across a network using a remote procedure call (hereinafter, abbreviated as "RPC"). About the system.

[0002] In the implementation, RPC processes individual processing requests from the network in a separate memory space by initiating a process for each request and processing in a common memory space using threads and queuing logic. However, this method can be applied to the latter.

[0003]

2. Description of the Related Art RPC is used to execute calls in procedural programming between computers across a network. RPC is a technology that allows a procedure on another computer across a network to be called like a procedure on a local computer. When one computer calls the procedure of another computer using RPC, the procedure is executed on the other computer, and when the execution of the procedure is completed, the result is returned from the latter to the former.

[0004]

By the way, in object-oriented programming, operations such as object creation, processing request, and deletion are performed on objects, instead of procedure calls as in procedural programming. With regard to such object operation in object-oriented programming, it is desirable that objects on another computer can be handled as if they were objects on a local computer, between computers across a network.

However, when an attempt is made to perform the same operation as the object operation in the local computer on an object on another computer via a network by using the above-mentioned conventional RPC as it is, the following will be performed. Problems arise.

FIG. 1 shows a normal program model when the object 2 is operated in the local computer 1. In this model, the main program 3 performs the following operation.

[0007] 1. An object generation request is issued, and as a result, the pointer of the object 2 generated in the object library 4 is obtained.

[0008] 2. Thereafter, using the obtained pointer,
A request for executing a desired process is issued to the object 2.

3. When the object 2 is no longer needed, a deletion request for the object 2 is issued using the obtained pointer.

As described above, in the ordinary program model in the local computer, the operation on the object is performed using the pointer of the generated object.

[0011] Such an object operation is performed by a conventional R
When an attempt is made to use an object on another computer by using a PC, the operation request must be converted into a simple procedural language interface provided by the RPC. For this reason, for example, it is inevitable to define the creation, processing request, and deletion of an object as a procedure (function) in a procedural language, and to set the above-described pointer as an argument of the function. However, when an object is created on another computer across a network, even if the pointer of the object is obtained, the pointer is used to specify the same object in another function call later because the memory space is different. There is no guarantee that you can use. In other words, if it is possible to generate an object and request the object to process and delete the object while one function is being called, 1
The operation of creating an object with one function call, requesting the object to process with another function call, and then destroying the object with another function call is not possible with the conventional method of exchanging pointers using RPC. It is possible. This makes it impossible to take advantage of the features of an object-oriented language that dynamically creates and accesses objects as needed.

SUMMARY OF THE INVENTION It is therefore an object of the present invention to provide a remote object access system capable of dynamically generating and accessing an object on a computer across a network using RPC.

[0013]

According to a first aspect of the present invention, there is provided a system in which a client computer creates an object on a server computer and accesses the object through an RPC (that is, requests execution of processing, and The object is generated, the client computer issues a procedural language interface generation request when the object is generated,
In response, the server computer creates an object, assigns a unique ID to the object, and returns the ID to the client computer as a response. Thereafter, the server computer manages the correspondence between the object ID and the pointer. And
The client computer issues an object access request of the procedural language interface by designating the object ID, and in response, the server computer accesses the object designated by the pointer corresponding to the ID.

A system according to a second aspect of the present invention comprises:
In addition to the above configuration, the client computer has a virtual object (client object) corresponding to an object (server object) in the server computer. The client object supports a method with the same name as the corresponding server object, issues a procedural language interface generation request and a deletion request at the time of its creation and deletion, and when it receives a request for a supported method, it issues this request. Converts to the corresponding request of the procedural language interface. The server computer generates and accesses a corresponding server object in response to a request from the client object. A system according to a third aspect of the present invention further includes a mechanism capable of designating a type (class) of an object to be generated, in addition to the configuration of the system according to the second aspect.

[0015] The program of each computer constituting the system of the present invention can be installed or loaded into the computer through various media such as a disk storage, a semiconductor memory, and a communication line.

[0016]

Embodiments of the present invention will be described below with reference to the accompanying drawings. In the following description, a computer that issues a request for operation (generation, processing execution, and deletion) of an object is referred to as a “client computer”, and a computer that executes the object operation in response to the request is referred to as a “server computer”.

A remote object access system according to a first embodiment of the present invention will be described with reference to FIGS.

The outline of this embodiment is as follows. That is, the server computer allocates a unique ID to the object when generating the object in response to the generation request from the client computer, holds a correspondence table between the pointer of the object and the ID, and stores the ID in the client. Return it as a response to the computer. The client computer
The ID from the server computer is held, and subsequent operations on the object on the server computer are performed by designating the ID of the object and calling a function.

FIG. 2 shows a normal program model in the local computer 1 on which the construction of the remote object access system according to this embodiment is based.

The program model shown in FIG. 2 has a new conversion logic library 5 between the main program 3 and the object library 4, as is apparent from comparison with the conventional program model shown in FIG. The conversion logic library 5 is a group of procedures (functions) for object operations such as object generation, processing execution request, and deletion. When the object generation function is called from the main program 3, the object 2 is stored in the object library 4. Is generated, a unique ID for identification is assigned to the object 2 at that time, and the pointer of the object 2 acquired from the object library 4 and the ID assigned to the object 2 are stored in the correspondence table 6. Retain and manage.

The operation of generating and accessing objects in this program model will be described below.

1. Object Generation The main program 3 issues an object generation function call to the conversion logic library. The conversion logic library 5 generates the object 2 in the object library 4, determines a unique ID, stores the obtained pointer and ID in the correspondence table 6, and returns the ID to the main program 3. I do. The main program 3 acquires the ID of the object 2 generated from the conversion logic library 5.

2. Object Processing Execution The main program 3 sets the acquired ID as an argument and issues a processing execution request function call for the object 2 to the conversion logic library 5. The conversion logic library 5 acquires a pointer corresponding to the ID from the correspondence table 6 and uses the pointer to
Issues a process execution request to

3. Object Deletion When the object 2 is no longer needed, the main program 3 sets the acquired ID as an argument and issues an object deletion function call to the conversion logic library 5.
The conversion logic library 5 uses the ID from the correspondence table 6
Of the object 2 is issued using the pointer.

FIG. 3 is a diagram showing how program units mounted on the client computer and the server computer of the system of the present embodiment are generated based on the conversion logic library 5 of the normal program model shown in FIG. It is.

When the conversion logic library 5 shown in FIG. 2 is input to a known RPC compiler 7, a conversion logic RPC client stub (hereinafter simply referred to as a client stub) 8 and a conversion logic RPC server library (hereinafter simply referred to as a server) are provided. 9) is automatically generated. Here, the client stub 8 and the server library 9 have the same function as the conversion logic library 5 shown in FIG. 2 as a whole by being connected by the RPC mechanism. The client stub 8 provides the same interface as the conversion logic library 5 to the main program 3, and has a function of converting this interface into an RPC procedural interface. The server library 9 holds and manages a correspondence table 10 corresponding to the correspondence table 6 in the conversion logic library 5, and has the original function of the conversion logic library 5, that is, the client stub 8 to R
It has a function of actually generating an object in response to an object operation request coming through the PC mechanism, issuing a processing execution request to the object, and deleting the object.

FIG. 4 shows a program model of the system according to the present embodiment constituted by a computer having the client stub 8 and the server library 9 mounted thereon.

As shown in FIG. 4, a client computer 11 and a server computer 12 exist over a network, and both can communicate with each other by an RPC mechanism 13. The client computer 11 includes the May program 3 and the client stub 8 shown in FIG. The server computer 12 includes the object library 4 and the server library 9 shown in FIG. The server library 9 stores the pointer and ID of each object 2 in the object library 4 as described above.
And a correspondence table 10. As mentioned above, RP
The client stub 8 and the server library 9 connected through the C mechanism 13 function just like the conversion logic library 5 of the normal program model shown in FIG. Since what is exchanged through the RPC mechanism 13 is not an object pointer but an ID,
Client computer 11 and server computer 1
It does not matter that the memory space differs between the two. Therefore, the client computer 11 can operate the object 2 on the server computer 12 via the network.

Next, the object operation in the system shown in FIG. 4 will be described.

1. Object creation Main program 3 of client computer 11
Issues an object generation function call to the client stub 8, the client stub 8 sends the function call to the server library 9 through the RPC mechanism 13. In response to this function call, the server library 9 generates the object 2 in the object library 4, obtains a pointer of the object 2 from the object library 4, assigns a unique ID to the object 2, and assigns the pointer and the ID to the object 2. Are stored in the table 10, and the ID is returned to the client stub 8 through the RPC mechanism 13. This ID is passed from the client stub 8 to the main program 3, and the main program 3 holds the ID.

2. Object Processing Execution The main program 3 sets the acquired ID as an argument and issues a call to a processing execution request function for the object 2 to the client stub 8. The client stub 8 sends the function call to the server library 9. The server library 9 acquires a pointer corresponding to the ID from the correspondence table 10 in response to the call, and issues a process execution request to the object 2 specified by the pointer.

3. Object Deletion When the object 2 is no longer needed, the main program 3 sets the acquired ID as an argument and issues an object deletion required function call to the client stub 8. The client stub 8 sends the function call to the server library 9. The server library 9 acquires a pointer corresponding to the ID from the correspondence table 10 and issues a deletion request to the object 2 specified by the pointer.

An implementation example of the conversion logic library 5 in the system of the present embodiment will be described below. An implementation example of a class called “ObjectA” of C ++, which is one of the object-oriented languages, will be described. Where Ob
“jctA” is “Action1” and “Action2”
It is assumed that there are three methods “Action3”. For simplicity, it is assumed that there is no parameter in the creation, destruction and method of ObjectA.

When the conversion logic library 5 is implemented, the following five functions are prepared as object operation functions using the procedural language C language.

1. Object creation function "Object
ACCreate (ID, ret) "This is a function for generating an instance (object) of the class ObjectA. When generating an instance of the class ObjectA, the function stores the pointer of the instance and the ID assigned to the instance in the correspondence table 10, and returns the ID and the generation result ret to the caller.

2. Object extinction function "Object
ADDelete (ID, ret) "This is a function for extinguishing an instance (object) of the class ObjectA. this function is,
Based on the passed ID, a pointer of the corresponding instance is acquired from the correspondence table 10, the instance specified by the pointer is deleted, the entry is deleted from the correspondence table 10, and the result ret is returned to the caller.

3. Action1 request function "Object
tAaction1 (ID, ret) "This is a function for requesting the method Action1 to the instance. This function acquires the pointer of the corresponding instance from the correspondence table 10 based on the passed ID, issues Action 1 to the instance specified by the pointer, and
The result of the action1 is returned to the caller as a result ret.

4. Action2 request function "Object
tAAction2 (ID, ret) "5. Actio
The n3 request function “ObjectAAction3 (ID,
ret) "Method to be issued is each Action
2. Except for Action 3, ObjectAAc
This is the same as the operation of the first time.

The above function of C is implemented as the conversion logic library 5 shown in FIG. 2, and the client stub 8 and the server library 9 obtained by compiling this as shown in FIG. 3 are shown in FIG. Is mounted on the computers 11 and 12 on the network, an instance of the class ObjectA is generated on the server computer 12 in response to a request from the client computer 11, and Action 1, Action 2 or Action is generated.
ion3 can be requested or deleted.

According to the first embodiment, an object can be generated on a remote computer, a process can be requested, and the object can be deleted.

(1) Information generated inside an object as a result of a processing request for the object can be held on a remote machine.

(2) Information generated inside an object can be extracted by an independent processing request.

(3) A plurality of computers can share an object on a remote computer.

Next, a remote object access system according to a second embodiment of the present invention will be described with reference to FIGS.
This will be described with reference to FIG.

The outline of this embodiment is as follows.
An object with the same interface as the object on the server computer (called a server object) (called a client object)
Is generated on the client computer. here,
The server object is a "true" object, while the client object is a "virtual" object whose interface is the same as the server object. When the main program in the client computer operates on the client object, the corresponding operation of the server object is executed on the server computer. In the first embodiment, the object operation from the main program has to be performed in a procedural language such as the C language, but in the second embodiment, it can be performed in an object-oriented language.

FIG. 5 shows a normal program model in a local computer on which a remote object access system according to this embodiment is built.

The local computer 21 has a main program 3, a conversion logic library 5 and an object library 4 in the same manner as the model shown in FIG.
A client object library 14 is provided between the main program 3 and the conversion logic library 5.
The client object library 14 has a client object 15 corresponding to each server object 2.

Hereinafter, an object operation in the above model will be described.

1. Generation of Object The main program 3 generates a client object 15 in the client object library 14. The client object 15 issues a call for an object generation function to the conversion logic library 5 during the generation processing. In response to this call, the conversion logic library 5 creates the server object 2, obtains a pointer to the object 2, assigns a unique ID to the object 2, stores the pointer and the ID in the correspondence table 6, and The ID is returned to the client object 15. The client object 15 holds the ID as an attribute.

2. Object processing execution The main program 3 is a client object 15
Request execution of the process. Client object 1
5 sets the ID held as an attribute as an argument and issues a call to a process execution request function to the server object 2 to the conversion logic library 5. The conversion logic library 5 acquires a pointer corresponding to the ID from the correspondence table 6, and issues a processing execution request to the server object 2 specified by the pointer.

3. Object Deletion The main program 3 deletes unnecessary client objects 15. In the disappearance processing, the client object 15 sets the ID held as an attribute as an argument and issues the ID to the call conversion logic library 5 of the object disappearance function. The conversion logic library 5 acquires a pointer corresponding to the ID from the correspondence table 6, and issues a deletion request to the server object 2 indicated by the pointer.

FIG. 6 shows a program model of the system of this embodiment constructed on the basis of the model shown in FIG.

As shown, the client computer 31 has a main program 3, a client object library 14, and a client stub 8. The server computer 32 stores the server library 9
And an object library 4. Here, as shown in FIG. 3, the client stub 8 and the server library 9 convert the conversion logic library 5 into a known RPC.
It is generated by compiling with a compiler.

The object operation in the system of the present embodiment is as follows.

1. Generation of Object The main program 3 generates a client object 15 in the object library 14. The client object 15 issues an object generation function call to the client stub 8 during the generation processing. The client stub 18 sends the function call to the server library 19 through the RPC mechanism 13.
The server library 9 generates the server object 2 in response to the call, obtains a pointer to the object 2, assigns a unique ID to the object 2,
The pointer and ID are stored in the correspondence table 10, and the ID is returned to the client stub 8. The client stub 8 passes the ID to the client object 15, and the client object 15 holds the ID as an attribute.

2. Object processing execution The main program 3 is a client object 15
To execute the process. Client object 15
Issues a process execution request function call to the server library 9 through the client stub 8 with the ID held as an attribute set as an argument. The server library 9
A pointer corresponding to the ID is acquired from the correspondence table 10, and a process execution request is issued to the server object 2 indicated by the pointer.

2. Object Deletion The main program 3 deletes unnecessary client objects 15. The client object 15 sets the ID stored as an attribute as an argument during the destruction processing, and executes an object destruction function call by RP
It is issued to the server library 9 through the C client stub 8. The server library 9 acquires a pointer corresponding to the ID from the correspondence table 10 and issues a deletion request to the server object 2 indicated by the pointer.

The following is an example of mounting the system of the present embodiment.

As in the implementation example of the first embodiment, C ++
“ObjectA” is a server object class, and it is “Action1”, “Action2”, “A”.
Ction3 ”method, the“ O
An implementation example of the present embodiment for “objectA” will be described.

First, similarly to the mounting example of the first embodiment,
Five functions of the C language "ObjectAcCreate (I
D, ret) "," ObjectADelete (ID,
ret) "" ObjectAAction1 (ID, r
et) ”,“ ObjectAAction2 (ID, re
t) ”“ ObjectAAction3 (ID, re
t) ”is prepared as the conversion logic library 5.

Next, the class Obj of the server object
A class ObjectB of a client object corresponding to ectA is prepared. If ObjectA is not used in the main program, the name of ObjectB may be the same as the name of ObjectA. In this ObjectB, a method having the same name as the method supported by ObjectA is prepared, and the method is implemented so that each method calls the above C function. The method is as follows:

1. Constructor (processing at generation) "Ob
objectB :: ObjectB ”This is the generation function ObjectACCreate (ID,
ret), and stores the returned ID internally.

2. Destructor (processing at the time of disappearance) "Obj
ectB :: 〜ObjectB ”This is an object function call ObjectADDelete (ID, ret) using the ID held inside.
Issue

3. "ObjectB :: Action
1 ”Using the internally stored ID, calls an Action1 request function ObjectAAction1 (ID, r
et).

4. "ObjectB :: Action
2 "5. "ObjectB :: Action3" These are called by Objectc
tAAction2 (ID, ret), ObjectA
Act 3 except for Action 3 (ID, ret)
Same as ion1.

According to the second embodiment, the following advantages can be obtained.

(1) Since a client object can be mechanically generated from an object to be arranged on a network, a network program can be easily generated.

(2) Objects on the network can be controlled by pointers in the same way as objects in the local computer.

(3) The object management logic in the local computer can be applied to objects on a remote computer.

(4) As an extension method of this embodiment, load distribution to the server computer and the client computer can be realized by partially implementing the actual processing without making the client object completely virtual.

Next, a remote object access system according to a third embodiment of the present invention will be described with reference to FIGS.
This will be described with reference to FIG.

In this embodiment, a mechanism capable of arbitrarily specifying the type (class) of an object to be operated is added to the second embodiment. To change the class of the object to be operated, the conversion logic library must be rebuilt in the second embodiment, but this is not necessary according to the present embodiment.

FIG. 7 shows a program model of the remote object access system according to the present embodiment.

The client computer 41 includes a main program 3, an object library 51, and an RPC client stub (hereinafter simply referred to as a client stub) 53 of conversion logic. The object library 51 includes a client object 52 and an ID assigned to the client object 52 (hereinafter referred to as an instance ID).
And a type ID indicating the object type (class).

The server computer 42 has an RPC server library (hereinafter simply referred to as a server library) 54 for conversion logic and an object library 56. The object library 56 holds a server object 57. The client object 52 has a one-to-one correspondence with the server object 57, and a specific configuration thereof will be described later. The server library 54 holds a correspondence table 10 between the pointer of the server object 57 and the instance ID, and a correspondence table 55 between the object type ID and the type (class) of the server object 57.

The client stub 53 and the server library 54 are generated by compiling the following conversion logic library using a known RPC compiler. This conversion logic library has the following three functions.

(1) Object generation function This function refers to the table 55 based on the object type ID included in the call from the client object 52 and recognizes the type (class) corresponding to the object type ID. , Creates a server object 57 of that type in the object library 56, assigns a unique instance ID to the object 57, stores the instance ID and pointer of the object 57 in the table 10, and furthermore, stores the instance ID in the client. Return to object 52. The server object 57 generated here is derived from the basic server object and constructed as described later.

(2) Object extinction function This function is based on the instance ID included in the call from the client
0 to obtain a pointer corresponding to the instance ID, and the server object 57 indicated by the pointer is obtained.
To extinguish.

(3) Processing request function This function is used to execute the processing in the table 1 based on the instance ID included in the call from the client object 52.
0 to obtain a pointer corresponding to the instance ID, and the server object 27 indicated by the pointer is obtained.
Requests the methods supported by the basic server object described later. The request of this method includes designation of a processing type described later.

FIG. 8 shows the configuration of the client object 52 and the server object 57.

In FIG. 8, the basic server object 6
1 is a server object of one class prepared in advance, and supports one method 60. The original object 65 is an object that the main program 3 intends to generate, and here supports three methods 62, 63, and 64 as an example.

As shown, the client object 5
2 is derived from the original object 25 and is constructed.
Has an object type ID assigned to the attribute as an attribute. The client object 52 provides an interface with the original object 65 to the main program 3 as depicted in the same form as the original object 65 in the drawing. This client object 52 can be said to be a virtual original object 65, and behaves as follows.

(1) A generation process is performed in response to a generation request from the main program 3. In the generation process, an object type ID possessed as an attribute is set in the conversion logic library as an argument, and It issues a call to the object generation function, and holds the instance ID returned from the conversion logic library as an attribute.

(2) Upon receiving a request for the method 62, 63 or 64 supported by the original object 65 from the main program 3, the conversion logic library receives the instance ID as an attribute and the requested method 62, 63 The processing type assigned to 63 or 64 is set as an argument and a call to the processing request function is issued. Note that the processing types of the methods 62, 63, and 64 are allocated between the client object 52 and the server object 57 at the time of construction.

(3) Deletion processing is performed in response to a deletion request from the main program. In the deletion processing, an instance ID possessed as an attribute is set as an argument to the conversion logic library and the object deletion function Issue a call.

As shown in FIG. 8, the server object 5
Numeral 7 is derived from two objects, an original object 65 and a basic server object 61, and has a method 60 supported by the basic server object 61 as an interface to the outside. Inside
Method 6 supported by original object 65
2, 63, 64, and these methods 62, 63,
Reference numeral 64 is associated with the above-described processing type.

When the server object 57 is requested by the conversion logic library for the method 60 supported by the basic server object 60, the server object 57 executes the method 62, 63 or 64 corresponding to the processing type included in the request.

With the above model, the main program 3
Can generate a true object (server object 57) of the class on the network by the same operation as generating an object (original object) of a desired type (class) in the own computer, and With the same operation of requesting a desired method for a desired object, the server object 57 on the network can execute the desired method.

According to the present embodiment, the following advantages can be obtained.

(1) Since a server object and a client object can be mechanically generated from an object to be arranged on a network, a network program can be easily generated.

(2) Objects on the network can be controlled by pointers, like objects in the computer.

(3) As long as the type of the object is not added, the conversion logic library does not need to be reconstructed even if the method of the object is changed.

While the preferred embodiments of the present invention have been described above, the present invention can be implemented in various other forms in which changes, modifications, improvements, and the like are made. For example, in the embodiment shown in FIGS. 4, 6, and 7, it is also possible to construct the client stubs 8 and 53 in the main program 3.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a normal program model in a conventional local computer.

FIG. 2 is a block diagram showing a normal program model on a local computer, which is a basis for building a remote object access system according to the first embodiment of the present invention.

FIG. 3 shows an RPC from the conversion logic library shown in FIG. 2;
5 is a flowchart showing a process of generating an RPC client stub and an RPC server library of conversion logic by a compiler.

FIG. 4 is a block diagram showing a program model of the remote object access system according to the first embodiment.

FIG. 5 is a block diagram showing a normal program model on a local computer which is a basis for building a remote object access system according to a second embodiment of the present invention.

FIG. 6 is a block diagram showing a program model of the remote object access system according to the first embodiment.

FIG. 7 is a block diagram showing a program model of a remote object access system according to a third embodiment of the present invention.

FIG. 8 is a diagram illustrating a configuration of an object according to a third embodiment.

[Explanation of symbols]

2, 57 server object 3 main program 4, 56 object library 5 conversion logic library 6, 10 correspondence table between object pointer and ID 8, 53 conversion logic RPC client stub 9, 54 conversion logic RPC server library 11, 31, 41 server computer 12, 32, 42 server computer 13 RPC mechanism 14, 51 client object library 15, 52 client object 55 object ID and type correspondence table

Claims (10)

[Claims] 1. A remote procedure call (RPC)
Through a remote object access system for a client computer to create an object on a server computer and access the object, the client computer comprising: an individual request for creation and access of the object originating on the client computer An RPC client stub that issues individual function calls for object creation and access to the server computer through the remote procedure call in response to the server computer. Generating a server object on the server computer in response to a call to an individual function from the RPC client stub, and An RPC server library for executing access to a server object is provided. The RPC client stub and the RPC server library exchange a unique instance ID assigned to each server object through the remote procedure call. A remote object access system comprising means for converting an instance ID of each server object into a pointer. 2. Remote procedure call (RPC)
Through a method for a client computer to create an object on a server computer and access the object, the method comprising: creating an object in response to individual requests for object creation and access occurring on the client computer. And a process in which the client computer functions as an RPC client stub that issues calls of individual functions for access to the server computer through the remote procedure call, and a function for generating and accessing the object. Generating a server object on the server computer and performing access to the server object in response to invocation of individual functions from the RPC client stub A process in which the server computer functions as a PC server library; a process in which the RPC client stub and the RPC server library exchange a unique instance ID assigned to each server object through the remote procedure call; The server library converting the instance ID of each server object to a pointer. 3. A remote procedure call (RPC)
Through a remote object access system for a client computer to create an object on a server computer and access the object, the client computer comprising: an individual request for creation and access of the object originating on the client computer; An RPC client stub that issues individual function calls for object creation and access to the server computer through the remote procedure call in response to the server computer; Generating a server object on the server computer in response to a call to an individual function from the RPC client stub, and An RPC server library for executing access to a server object, wherein the RPC server library assigns a unique instance ID to the generated server object,
Holding a correspondence table between the instance ID of each server object and the pointer, and assigning the instance ID assigned to the generated server object to the RPC
Returning to a client stub, wherein the RPC client stub includes, when issuing a function call for accessing each server object, an instance ID of each returned server object in the function call. Object access system. 4. The system of claim 3, wherein the client computer further comprises a client object created in response to the request for object creation, wherein the client object comprises: (1) Instructing the RPC client stub to issue a function call for generating the object, receiving and holding the instance ID returned as a result of execution of the generation function from the RPC client stub, and (2) A remote object access system, in response to a request for access to the object, instructing the RPC client stub to issue a function for access using the stored instance ID. 5. The system according to claim 4, wherein said client object further has an object type ID indicating an object type, and said client object is generated using said object type ID when said client object is generated. The RPC client stub instructs the RPC client stub to issue a function call for the object. When issuing the function call for generating the object, the RPC client stub includes the object type ID in the function call. Further has a correspondence table between the object type and the object type ID, and in response to the function call for generating the object, the original object belonging to the object type corresponding to the object type ID is displayed. Remote Object Access system and generates a server object having methods that port. 6. The system according to claim 5, wherein the client object is derived from the original object and constructed, and can receive a request for a method supported by the original object. Is constructed by deriving from the original object and a predetermined basic server object, and can receive a request for a method supported by the basic server object. The client object is further supported by the original object. In response to a request for a method to be executed, a process type pre-assigned to the method is designated, and a call to a process request function for a method supported by the basic object is issued. RP
C client stub, and further, the RPC server library specifies a processing type in response to a call of a processing request function for a method supported by the basic object, and requests the method supported by the basic server object. Is issued to the server object, and the server object further executes a method corresponding to the processing type among the methods supported by the original object in response to a request for a method supported by the basic server object. A remote object access system. 7. A remote procedure call (RPC)
Through a remote object access system for a client computer to create an object on a server computer and access the object, the client computer comprising: an object for generating and accessing the object generated on the client computer; An RPC client stub that issues individual function calls for creation and access of objects to the server computer through the remote procedure call in response to the request of For generating a server object on the server computer in response to invocation of individual functions from the RPC client stub, and An RPC server library for executing access to a server object is provided. The RPC client stub and the RPC server library exchange a unique instance ID assigned to each server object through the remote procedure call. A computer-readable recording medium carrying a program for causing a computer to function as the client computer in a remote object access system having means for converting an instance ID of each server object into a pointer. 8. A remote procedure call (RPC)
Through a remote object access system for a client computer to create an object on a server computer and access the object, the client computer comprising: an object for generating and accessing the object generated on the client computer; An RPC client stub that issues individual function calls for creation and access of objects to the server computer through the remote procedure call in response to the request of For generating a server object on the server computer in response to invocation of individual functions from the RPC client stub, and An RPC server library for executing access to a server object is provided. The RPC client stub and the RPC server library exchange a unique instance ID assigned to each server object through the remote procedure call. A computer-readable recording medium carrying a program for causing a computer to function as the server computer in a remote object access system having means for converting an instance ID of each server object into a pointer. 9. A remote procedure call (RPC)
Through a remote object access system for a client computer to create an object on a server computer and access the object, the client computer comprising: an object for generating and accessing the object generated on the client computer; An RPC client stub that issues individual function calls for creation and access of objects to the server computer through the remote procedure call in response to the request of For generating a server object on the server computer in response to invocation of individual functions from the RPC client stub, and An RPC server library for executing access to a server object, wherein the RPC server library assigns a unique instance ID to the generated server object,
Holding a correspondence table between the instance ID of each server object and the pointer, and assigning the instance ID assigned to the generated server object to the RPC
A remote object access system, wherein when returning a function call for accessing each server object, the RPC client stub includes an instance ID of each returned server object in the function call. A computer-readable recording medium carrying a program for causing a computer to function as the client computer. 10. A remote procedure call (RP
C) a remote object access system for a client computer to create an object on a server computer and access the object through the client computer, wherein the client computer is for creating and accessing the object generated on the client computer; An RPC client stub that issues individual function calls for object creation and access to the server computer through the remote procedure call in response to individual requests of the server computer; Creating a server object on the server computer in response to a call to an individual function from the RPC client stub with a function for accessing; An RPC server library for executing access to the server object, wherein the RPC server library assigns a unique instance ID to the generated server object,
Holding a correspondence table between the instance ID of each server object and the pointer, and assigning the instance ID assigned to the generated server object to the RPC
A remote object access system, wherein when returning a function call for accessing each server object, the RPC client stub includes an instance ID of each returned server object in the function call. A computer-readable recording medium carrying a program for causing a computer to function as the server computer.