From: Gail Rahn (grahn_at_cs.washington.edu)
Date: Mon Feb 02 2004 - 16:22:26 PST
Review of "Implementing Remote Procedure Calls" by Birrell and Nelson
The "Implementing RPC" paper is the seminal paper introducing a lightweight
RPC architecture that connectes computers across an Ethernet network. The
authors extended the local procedure call mechanism to execute procedures on
remote computers. This paper is distinguishable form previous RPC papers
because the authors actually implemented a system running the design on an
existing network at Xerox PARC.
The RPC methodology was selected because of three major design features:
clear and simple semantics (easy for programmers to use RPC), efficiency
(RPC is lightweight) and generality (RPC can be run across heterogeneous
machines). RPC has been implemented in a high-level programming language,
allowing distributed software designers to concentrate in logic and data
design, rather than become concerned with communication protocols and
parameter-marshaling. Ease-of-use was a strong concern of the RPC designers
because wide adoption is necessary for the protocol to be successful.
The authors rejected the notion of shared address space, and remote address
space references, because of efficiency and security concerns.
RPC was also a natural architecture selection for distributed computing
because LPC (local procedure calls) were already the standard
control-transfer and data-transfer mechanism inherent in computers. RPC
maintains many of LPC's concepts and physical characteristics. To client
and server machines, RPC should look an awful lot like LPC.
A program takes advantage of this RPC system by declaring a set of
procedures that are imported and exported. Special compilation occurs on
these functions, using a program called Lupine, to create stub functions for
caller and callee. These stub functions automatically handle parameter
marshalling, security, server-binding and all caller/callee communications.
The client machine needs only call the exported RPC as an other local
function. The RPC layer of the operating system handles finding an
appropriate server and passing parameters and result between the machine.
(Grapevine is used as the lookup for finding servers associated with a
specific interface and also for authentication.)
An advantage of this design is that only procedures explicitly marked as
exported/imported are available for RPC. A client cannot request an
arbitrary procedure on the server machine. This is a layer of security.
RPC also guarantees that the server executes the RPC only once for each
client request. Packets sent between client and server contain identifiers
for the call, client and server machines, processes to ensure that all
necessary packets are transmitted and received, and that server acks are
sent under the right circumstances.
The authors measured sample RPC calls between computers at PARC and found
their design to achieve the same throughput as highly-optimized byte stream
implementations.
This paper was an extremely clear read and handled. I am especially
appreciative of the Author's architecture for automatically wrapping remote
procedure calls, so that programmers of distributed systems can keep their
minds at a high-level and need not worry about the specifics of transfer
protocols, marshaling, etc.
-------------------------
Gail Rahn
grahn_at_cs.washington.edu
This archive was generated by hypermail 2.1.6 : Mon Feb 02 2004 - 16:22:37 PST