CSE 221: Paper Evaluations

Renata C TEIXEIRA (teixeira@cs.ucsd.edu)
Wed, 17 May 2000 20:48:24 -0700 (PDT)

Title: "Lightweight Remote Procedure Call"

This paper describes Lightweight Remote Procedure Calls (LRPC), a
communication facility designed and optimized for communication
between protection domains on the same machine. The idea is to
use the semantics of RPC for cross-domain procedure calls thereby
providing RPC's safety and transparency, but achieving a better
performance. In order to achieve better performance the paper
proposes four techniques: simple control transfer, simple data
transfer, simple stubs, and design for concurrency.

Simple data transfer is accomplished by sharing argument stacks
between client and server. The execution stacks remain separate
and calls are handled by the kernel to ensure protection. Clients
must have a capability (binding object) to the procedure in
order to do a successful call. Simple control is performed by
recording the caller's return address on a linkage record,
accessible only to the kernel. Thus, the client execute on
the server context and then return. On a multiprocessor,
LRPC reduces context-switch overhead by caching domains on
idle processors.

I think that this paper is very well written and that it presents
a thorough discussion of the motivations for introducing LRPC.
The idea of having a RPC optimized for cross-domain calls is
very interesting. The user can write distributed applications
and ignore completely whether they are on the same machine or
not. Furthermore, when client and server are on the same machine
the overhead necessary for cross-machine communication is
eliminated allowing a better performance.

-------------------------------------------------------------------
Title: "Active Messages: A Mechanism for Integrated Communication and Computation"

This paper introduces active messages, a simple communication mechanism that
integrates communication with computation to obtain a better performance on
parallel computations. Active messages is an asynchronous communication mechanism
in which each message contains at its head the address of a user level handler
which is executed on the arrival of the message with the message body as
argument.

Active messages generalize the hardware functionality for message passing by
allowing the sender to specify the address of the handler to be invoked on
message arrival. Handlers execute immediately upon message arrival, cannot
suspend, and have the responsibility to terminate quickly enough not to
back-up the network. The key optimizations in active messages are the elimination
of buffering and overlapping communication with computation.

I think that the idea to avoid the software overhead on communication and use
a model closer to hardware is well suited for parallel applications on a
multiprocessor machine or cluster. Active messages, however, don't seem easy
to use and demand high knowledge of programmers.