Remote procedure calling with marshaling and unmarshaling of arbitrary non-conformant pointer sizes

• US 6,298,391 B1
• Filed: 03/13/1998
• Issued: 10/02/2001
• Est. Priority Date: 03/13/1998
• Status: Expired due to Term

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation), Software AG
• Original Assignee: Microsoft Corporation
• Inventors: Kott, Ryszard K., Brown, Nathaniel S., Kennedy, Terry, Ewbank, Christopher Gustav, Goertzel, Mario C., Gaertner, Dietmar
• Primary Examiner(s): BANANKHAH, MAJID A
• Application Number:
  US09/040,226
• Time in Patent Office: 1,299 Days
• Field of Search: 709/304, 709/310-332, 395/701
• US Class Current: 719/328
• CPC Class Codes: G06F 9/547 Remote procedure calls [RPC]; Web services

Abstract

A remote procedure call marshaling architecture provides remote procedure call interoperability between computers having arbitrary native data format pointer sizes not conforming to an on-wire multicanonical data representation of the remote procedure calls. The architecture includes an interface description language compiler having a code path generic to effecting marshaling of data structures containing non-conformant pointers. When compiled to run on a computing platform having a native, non-conformant pointer size, the code path is automatically configured to effect marshaling of data structure containing pointers of the computing platform'"'"'s native pointer size.

Claims

1. A method of generically marshaling data for a remote procedure call from a data format with arbitrary pointer sizes not conforming to an on-wire multicanonical representation, the method comprising:

providing an interface definition language compiler having a routine for generating marshaling code to effect a remote procedure call, the routine having a code path generic to marshaling of data containing pointers of any arbitrary size not conforming to the on-wire multicanonical representation;

compiling the interface definition language compiler to run on a target computing platform having a non-conformant pointer size such that the code path of the routine becomes operative to generate marshaling code to effect marshaling of data containing pointers of the non-conformant pointer size; and

running the interface definition language compiler on a computer having the target computing platform to generate marshaling code for issuing inter-computer remote procedure calls in the on-wire multicanonical representation on a distributed network.

2. The method of claim 1 wherein the interface definition language compiler contains a statement that automatically configures the code path to the non-conformant pointer size when the interface definition language compiler is compiled to run on the target computing platform.

3. The method of claim 1 wherein the interface definition language compiler further has a routine for generating unmarshaling code to effect a remote procedure call, the routine having a second code path generic to unmarshaling of data containing pointers of any arbitrary size not conforming to the on-wire multicanonical representation, the compiling the interface definition language compiler to run on the target computing platform causing the second code path to become operative to generate unmarshaling code to effect unmarshaling of data containing pointers of the non-conformant pointer size.

4. The method of claim 1 wherein the compiling the interface definition language compiler is performed using a programming language compiler resident on a computer of the target computing platform.

5. The method of claim 1 wherein the compiling the interface definition language compiler is performed using a cross compiler resident on a computer of a different second computing platform and operative to compile the interface definition language compiler to the target computing platform.

10. The method of claim 1 wherein issuing comprises:

checking whether a pointer in a memory buffer is null or non-null;

writing a flag value to a remote procedure call buffer, the flag value indicating whether the checked pointer is null or non-null, wherein the flag value has a size conforming to the on-wire multicanonical representation.

11. The method of claim 10 wherein issuing further comprises:

incrementing a memory buffer pointer by the non-conformant pointer size; and

incrementing a remote procedure call buffer pointer by the size conforming to the on-wire multicanonical representation.

12. The method of claim 1 wherein issuing comprises:

for a pointer in a memory buffer, representing the pointer in a remote procedure call buffer;

incrementing a memory buffer pointer by the non-conformant pointer size; and

incrementing a remote procedure call buffer pointer by a size conforming to the on-wire multicanonical representation.

6. A marshaling architecture for remote procedure call interoperability in a distributed environment of heterogeneous computers potentially having a data format with an arbitrary pointer size not conforming to an on-wire multicanonical representation, the architecture comprising:

an interface definition language compiler for generating marshaling and unmarshaling code of a proxy and a stub to be run in-process of a client and a server component, respectively, the proxy receiving an interface function call from the client and causing the stub to issue the interface function call to the server component across process and machine boundaries via a remote procedure call, the proxy and the stub marshaling data from and unmarshaling data to their respective process through a remote procedure call buffer;

a generic non-conformant pointer size marshaling code path in the interface definition language compiler for generically effecting marshaling and unmarshaling by the proxy and the stub through the remote procedure call buffer of data containing pointers having any of a variety of arbitrary pointer sizes non-conformant with the on-wire multicanonical representation when run on a computer in the distributed environment having a native data format pointer size of the variety; and

a remote procedure call transport for transferring the remote procedure call buffer in the multicanonical representation across the process and machine boundaries between the proxy and the stub.

7. The marshaling architecture of claim 6 which is compilable to a computing platform of one or more computers in the distributed environment where the computing platform has a native data format pointer size of the variety, to thereby cause the generic non-conformant pointer size marshaling code to effect marshaling and unmarshaling of data containing pointers of the computing platform'"'"'s native data format pointer size when run on said computers.

8. A computer readable storage medium having computer-executable code stored thereon of a remote procedure call facility generic to marshaling remote procedure calls on computers having arbitrary native data format pointer sizes not conforming to a multicanonical representation, the remote procedure call facility comprising interface definition language compiling code for generating proxies and stubs for a remote procedure call between a client and server application on separate computers, and having a code path generic to marshaling data containing pointers of an arbitrary non-conformant pointer size for transfer via the remote procedure call in the multicanonical representation.

9. The computer readable storage medium of claim 8 wherein the interface definition language compiler is compiled to run on a computer having a native data format pointer size not conforming to the multicanonical representation whereby the code path is operative to generate proxies that marshal data containing pointers of the native data format pointer size for transfer via the remote procedure call in the multicanonical representation.

13. A method of initializing an interface definition language compiler for use on a computer of a computer platform type, the computer platform type having pointers with a size that differs from an RPC-wire standard, the method comprising:

providing an interface definition language compiler for generating RPC-enabling code, the interface definition language compiler including instructions for handling pointer data of an arbitrary pointer size in the RPC-enabling code;

with a platform-generic operation, automatically determining a platform pointer size for a computer, the platform pointer size differing from an RPC-wire standard;

based upon the determined platform pointer size, configuring the interface definition language compiler to generate RPC-enabling code that handles pointer data of the platform pointer size in an RPC-wire standard compliant manner.

14. A computer-readable storage medium having computer-executable code stored thereon for performing the method of claim 13.

15. The method of claim 13 wherein configuring the interface definition language compiler comprises:

setting a memory buffer pointer size value to the platform pointer size.

16. The method of claim 13 wherein RPC-enabling code includes instructions for:

determining if a pointer is null or non-null;

writing a flag value to an RPC buffer, the flag value indicating whether the pointer is null or non-null, wherein the flag value has an RPC-wire standard pointer size.

17. A method of initializing an interface definition language compiler for use on a computer of a computer platform type, the computer platform type having pointers with a size that differs from an RPC-wire standard, the method comprising:

providing an interface definition language compiler for generating RPC-enabling code, the interface definition language compiler including instructions for handling pointer data of an arbitrary pointer size in the RPC-enabling code;

determining a platform pointer size for a computer, the platform pointer size differing from an RPC-wire standard;

based upon the determined platform pointer size, configuring the interface definition language compiler to generate RPC-enabling code that handles pointer data of the platform pointer size in an RPC-wire standard compliant manner, wherein the RPC-enabling code includes instructions for;

determining if a pointer is null or non-null;

writing a flag value to an RPC buffer, the flag value indicating whether the pointer is null or non-null, wherein the flag value has an RPC-wire standard pointer size;

incrementing a memory buffer pointer by the platform pointer size; and

incrementing an RPC buffer pointer by the RPC-wire standard pointer size.

18. A method of initializing an interface definition language compiler for use on a computer of a computer platform type, the computer platform type having pointers with a size that differs from an RPC-wire standard, the method comprising:

providing an interface definition language compiler for generating RPC-enabling code, the interface definition language compiler including instructions for handling pointer data of an arbitrary pointer size in the RPC-enabling code;

determining a platform pointer size for a computer, the platform pointer size differing from an RPC-wire standard;

based upon the determined platform pointer size, configuring the interface definition language compiler to generate RPC-enabling code that handles pointer data of the platform pointer size in an RPC-wire standard compliant manner, wherein the RPC-enabling code includes instructions for;

determining if a pointer is null or non-null;

writing a flag value to an RPC buffer, the flag value indicating whether the pointer is null or non-null, wherein the flag value has an RPC-wire standard pointer size;

in a dictionary, associating a unique non-null pointer with a unique flag value for the unique non-null pointer; and

based upon the dictionary, when the unique non-null point is later marshaled, writing the unique flag value to the RPC buffer.

19. A method of initializing an interface definition language compiler for use on a computer of a computer platform type, the computer platform type having pointers with a size that differs from an RPC-wire standard, the method comprising:

providing an interface definition language compiler for generating RPC-enabling code, the interface definition language compiler including instructions for handling pointer data of an arbitrary pointer size in the RPC-enabling code;

determining a platform pointer size for a computer, the platform pointer size differing from an RPC-wire standard;

based upon the determined platform pointer size, configuring the interface definition language compiler to generate RPC-enabling code that handles pointer data of the platform pointer size in an RPC-wire standard compliant manner, wherein the RPC-enabling code includes instructions for;

for a pointer in a memory buffer, representing the pointer in an RPC buffer;

incrementing a memory buffer pointer by the platform pointer size; and

incrementing an RPC buffer pointer by an RPC-wire standard pointer size.