CSE 221: Paper Evaluations

Renata C TEIXEIRA (teixeira@cs.ucsd.edu)
Mon, 15 May 2000 20:59:14 -0700 (PDT)

Title: "Implementing Remote Procedure Calls"

This paper discusses design and implementation issues for remote
procedure calls (RPC) for providing communication between processes
across a network. The aim was to make distributed computation easy
and efficient. In addition, the semantics of the RPC package should
be as powerful as possible, without loss of simplicity or efficiency;
and it should provide secure communication.

When making a remote call, five pieces of program are involved: the
user, the user-stub, the RPC communications package, the server-stub,
and the server. The stubs are automatically generated and are responsible
for packing and unpacking arguments and results, and for dispatching
the correct procedure on servers. The user and server codes make only
local calls to stubs. RPC communications package is responsible for
retransmissions, acknowledgements, packet routing and encryption. In
order to locate servers, the RPC package uses the Grapevine distributed
database to store servers information.

The transport protocol implementation was optimized for RPC by: using
subsequent packets for implicit acknowledgements of previous packets,
minimizing the costs of maintaining connections, avoiding costs of
establishing and terminating connection, reducing the number of
process switches in a call, and bypassing protocol layers for RPC
packets in the same local network.

I think that the RPC package provides a powerful and easy-to-use
service. Locating servers may be performed by just specifying the
type of service without the knowledge of the user of a specific
machine. Handling communication errors using exceptions and
minimizing the load in servers are also important features.
One drawback of the system is how it handles applications that
transfer large amount of data or execute for a long time. There
is no asynchronous call and acknowledgements are issued per
packet.
----------------------------------------------------------------
Title: "Performing Remote Operations Efficiently on a Local Computer Network"

This paper describes a model for interprocess communication in local networks
using remote references as basis. The idea is to reduce the overhead
of network communication and use high speed local networks in order
to allow for fine grain parallel computations.

The communication model presented is a remote reference/remote operation
that not only transfers data but also initiates operations and returns
their values. There are five attribute classes associated with
references based on: varying reliability semantics, whether a value
is returned, how the remote operation occurs temporally with respect
to the reference, the need for flow control, and the kind of process
by which the operation will be performed.

The communication subsystem uses an integrated approach, thereby
avoiding overhead to cross layer boundaries, and provides functions
suitable for implementing high level primitives. Each host has one
communication process that is responsible for maintaining system
sessions and to handle remote references and initiate remote execution.
In order to implement all attribute classes, the paper proposes the
use of three different protocols: request, request/response, and
request/response/acknowledgement-response.

I think that the rich semantics supported by attribute classes to
remote references together with their different implementation
protocols provides a very expressive communication service.
The possibility of fault recovery through the use of recoverable
processes and sockets is another desirable feature. Since the paper
proposes only a model there are some implementation details that
are not discussed, like how to locate remote processes and how to
implementation protection.

-- Renata Teixeira