From: Sellakumaran Kanagarathnam (sellak_at_windows.microsoft.com)
Date: Wed Jan 28 2004 - 18:24:28 PST
The paper discusses an early implementation of RPC package in Xerox Palo
Alto Research center. The idea of RPC is to give a simple way for
distributing computation very similar to local procedure call. At the
time this was implemented, there was already some literature on RPC, but
there was no actual system that implemented RPC.
The system was developed in the Cedar programming environment involving
Dorado computers, then very powerful. There were 3MBPS and 10 MBPS
networks in the environment and the protocol used for communications was
PUP. The programming was done using a high-level language called Mesa.
The authors' primary aim was to make distributed computing easy by
taking the issues of communication away from the programmer. Efficiency
and security were the other aims. The authors discuss the various
design alternatives that they faced: message passing, remote forking,
shared address space among computers. But Mesa language support and no
perceivable advantages in other alternatives led them to RPC. Within RPC
the primary principle that helped in many design choices was to make RPC
semantically as close as possible to local procedure calls. For example
their RPC does not have time-out because local procedure calls did not
have any time-outs.
The RPC is based on the concept of stubs. The five pieces involved are:
user, user-stub, RPC communication package, server-stub and server. The
idea involved is that if the servers and users are combined, the
application would run with out the RPC. The binding involved naming and
locating an appropriate exported. Naming involved specifying the type
and the instance. Example given is a mail server as type and a specific
mail server as an instance. They used the Grapevine database for
locating an exporter. The servers use ExportInterface to register an
interface (which involves an interface and a procedure in the
server-stub). The clients use ImportInterface to bind to a server. The
RunTime queries the Grapevine database for the network address of the
server and then makes a remote procedure call on the server to get the
binding information. The server yields a unique identifier and a table
index to the importer (user). The user-stub remembers the exporter's
network address (from Grapevine), identifier and the index. Subsequent
calls use this information, part of them in the call itself. The unique
identifier scheme ensures that the bindings are broken if the server
crashes for some reason (& reboots).
The authors then discuss the transport protocol. They deal with two
types of calls: a simple call where all of the arguments will fit in the
buffer (and all of results will fit in the buffer). To make a call in
this space, the caller sends a packet containing a call id, procedure
info and arguments. When the callee machine receives this packet, the
appropriate procedure is called and the result packet is sent back. The
other type is a complicated call: here the retransmission &
acknowledgements are used.
The RPC package also emulates Mesa's exception handling (where in a
server sends an exception packet to the caller and the caller-stub
catches this and raises an exception.
Given the author's aims and goals, the system seems to satisfactorily
cover them. Overall this is a nice paper that clearly explains the RPC
package that they developed.
This archive was generated by hypermail 2.1.6 : Wed Jan 28 2004 - 18:24:35 PST