US Patent 5,724,588: Method and system for network marshalling of interface pointers for remote procedure calls - Part II (Microsoft Corporation)

Title: Method and system for network marshalling of interface pointers for remote procedure calls (Part II)
Patent Number: US Patent 5,724,588
Issued: March 3, 1998
Filed: June 7, 1995
Parent case: This application is a continuation of U.S. patent application Ser. No. 08/158,627, filed Nov. 29, 1993, now US Patent 5,511,197 (Microsoft Corporation)Φ.
Inventor(s): Hill, Richard D. et al.
Assignee: Microsoft Corporation
Distinguished after issuance from: US Patent 6,438,560 (IBM Corporation) Φ, US Patent 6,671,696 (Pardalis Inc.) and US Patent 7,136,869 (Pardalis Inc.)
Blogger comment: 

There were 12 prior US patents referenced at issuance, none of which are remarkable for the scope and purposes of this blog.

An advanced search at USPTO online on April 23, 2008 for references to this patent using ref/5724588 reveals 119 references. A more refined search of the claims of these referenced patents reveals hits for US Patent 6,438,560, US Patent 6,671,696 and US Patent 7,136,869.

Abstract:

A computer method and system for passing a pointer to an interface from a server process to a client process.

Independent claims (as numbered):

1. A method in a computer system for providing a client with access to a client implementation of an interface corresponding to a server implementation of the interface provided by a server, comprising:

under control of the server, sending to the client an indication of unmarshalling code and information for use by the unmarshalling code to provide the client implementation of the interface that corresponds to the server implementation of the interface; and

under control of the client,

receiving the indication of the unmarshalling code and the information; and

executing the indicated unmarshalling code to generate a pointer to the client implementation of the interface in accordance with the received information

whereby the client uses the generated pointer to access the client implementation of the interface.

3. The method of claim 1 wherein the interface has a function member that provides a behavior, wherein the server implementation of the interface has associated state information and wherein the sending of information to the client includes the state information, and including

under control of the client,

using the generated pointer to invoke the function member of the client implementation of the interface wherein the invoked function member accesses the received state information to provide the behavior of the function member without requesting that the server invoke the function member of the server implementation of the interface.

4. The method of claim 3 wherein the state information is immutable information.

11. A computer system for providing a client with access to a client interface through which the client accesses a server, comprising:

server means for sending to the client an indication of unmarshalling code and information for use by the unmarshalling code to provide the client interface; and

client means for receiving the indication of the unmarshalling code and the information, and executing the indicated unmarshalling code to generate a pointer to the client interface in accordance with the received information whereby the client uses the generated pointer to access the server through the client interface.

16. A method in a computer system for unmarshalling a pointer to a server interface sent from a server to a client, the server interface for providing a service to the client, comprising:

receiving an indication of unmarshalling code and information describing the server interface of the server;

locating the unmarshalling code indicated by the received indication;

executing the located unmarshalling code to generate a pointer to a client interface; and

using the generated pointer to invoke a function member of the client interface wherein the invoked function member provides the service to the client using the information describing the server interface.

19. A method in a computer system for custom marshalling of a pointer to an object from a server to a client, the object having data members and function members comprising:

instantiating the object;

determining whether custom marshalling code is provided for the object;

when it is determined that custom marshalling code is provided, executing custom marshalling code to provide an indication of custom unmarshalling code and information describing the object to the custom unmarshalling code; and

when it is determined that custom marshalling code is not provided, executing standard marshalling code to provide an indication of standard unmarshalling code and information describing the object to the standard unmarshalling code; and

sending the provided indication and information to the client so that the client can execute the indicated unmarshalling code to provide a custom or standard proxy object through which to request services of the instantiated object.

23. A method in a comptuer system for marshalling a pointer to an interface from a first server to a client, the pointer pointing to an interface of the first server that is marshalled from a second server, the interface having a function member providing a behavior, wherein the client, the first server, and the second server each have an implementation of the function member, wherein the implementation of the function member of the first server requests the implementation of the function member of the second server to perform the behavior of the function member, comprising:

under control of the first server, sending to the client an indication of unmarshalling code and information indicating the second server; and

under control of the client,

receiving the indication of the unmarshalling code and the information; and

executing the indicated unmarshalling code to generate a pointer to an interface with a client implementation of the function member that when invoked requests the second server to provide the behavior

whereby when the client implementation of the function member is invoked, then the client requests the second server to perform the behavior without requesting the first server to perform the behavior.

24. A computer-readable medium containing instructions for causing a computer system to provide a client with access to a client implementation of an interface corresponding to a server implementation of the interface provided by a server by:

under control of the server, sending to the client an indication of unmarshalling code and information for use by the unmarshalling code to provide the client implementation of the interface that corresponds to the server implementation of the interface; and

under control of the client,

receiving the indication of the unmarshalling code and the information; and

executing the indicated unmarshalling code to generate a pointer to the client implementation of the interface in accordance with the received information.

26. The computer-readable medium of claim 24 wherein the interface has a function member that provides a behavior, wherein the server implementation of the interface has associated state information and wherein the sending of information to the client includes the state information, and including

under control of the client,

using the generated pointer to invoke the function member of the client implementation of the interface wherein the invoked function member accesses the received state information to provide the behavior of the function member without requesting that the server invoke the function member of the server implementation of the interface.

27. The computer-readable medium of claim 26 wherein the state information is immutable information.

34. A computer-readable medium containing instructions for causing a computer system to marshal a pointer to an object from a server to a client, the object having data members and function members by:

instantiating the object;

determining whether the custom marshalling code is provided for the object;

when it is determined that custom marshalling code is provided, executing custom marshalling code to provide an indication of custom unmarshalling code and information describing the object to the custom unmarshalling code; and

when it is determined that custom marshalling code is not provided, executing standard marshalling code to provide an indication of standard unmarshalling code and information describing the object to the standard unmarshalling code; and

sending the provided indication and information to the client so that the client can execute the indicated unmarshalling code to provide a custom or standard proxy object through which to request services of the instantiated object.

Key Drawings(s):

"FIG. 13 [below] is a block diagram illustrating custom marshalling with shared memory. In certain situations, an object may store its data members in memory that is shared across processes to avoid the overhead of remote procedure calling to access the data members. In FIG. 13, the data 1302 for cell object 1301 is stored in shared memory. Cell object 1303 is created when a pointer to cell object 1301 is marshalled and sent from process P1 to process P2. The custom methods of the IMarshal interface for a cell object are implemented by the following pseudocode.

void IMarshal::MarshalInterface (pstm, iid, pInterface, DestContext)
     { if(DestContext = Shared) then
          { Marshal (pstm, address of data);}
     else
          { MakeStub ("Cell", iid, pInterface, &MessageAddress);
          Marshal (pstm, MessageAddress)};
     }
void IMarshal::GetUnmarshalClass (iid, pInterface, DestContext, cid)
     { if (DestContext = Shared)
          {cid = "Cell"}
     else
          {cid = "CellProxy"}
     }
void IMarshal::UnMarshalInterface (pstm, iid, pInterface);
     { UnMarshal (pstm, address of data);
      initialize object to point to shared data
     }

The parameter DestContext of the method IMarshal::MarshalInterface indicates whether the data of the cell object is stored in shared memory. If the data is not stored in shared memory, then the equivalent of the standard marshalling is performed. If, however, the data is stored in shared memory, then the address of the shared data is marshalled into the message. The method IMarshal::GetUnmarshalClass determines the unmarshal class based on whether the data is in shared memory. If the data is not in shared memory, then the CellProxy class is the unmarshal class. If the data is in shared memory, then the Cell class is the unmarshal class. The unmarshal class and address of the shared data are sent to process P2. After process P2 instantiates the cell object 1303, the process P2 invokes the custom method IMarshal::UnMarshalInterface, which unmarshals the address of the shared data and initializes the object to point to the data."

[Original image modified for size and/or readability]"Custom marshalling can be used to provide more efficient access to immutable objects. An immutable object is an object whose data members (state) cannot be changed. When an interface pointer to an immutable object is passed from one process to another, custom marshalling can be used to make a copy of the object in the other process. Thus, when the other process accesses the object, it accesses the local copy and no interprocess communication is needed. To allow copying of immutable objects, the methods of the IMarshal interface of the immutable objects are implemented in the following way. In a preferred embodiment, the method IMarshal::GetUnMarshallClass specifies that the unmarshal class is the same class as the class of the immutable object. This ensures that the same type of object is instantiated by the other process. The method IMarshal::MarshalInterface stores the data members of the immutable object into a message for passing to the other process. The method IMarshal::MarshalInterface creates no stub. When the other process receives the message, the other process creates an object of the class of the immutable object. The method IMarshal::UnMarshalInterface then retrieves the data members from the message and initializes the newly-created object. The other process can then access the immutable object."