paper evaluations: 05/16

Alejandro Hevia (
Tue, 16 May 2000 04:08:10 -0700 (PDT)

Evaluation of paper
"Performing Remote Operations Efficiently on a Local Computer Network"
by A.Z. Spector

The paper introduces a communication model for a (claimed efficient)
communication subsystem for a local network. This model relies on the concept of
remote reference which is a remote operation which may be followed by the
transmission of a result value. This operation is intentionally kept simple
in order to be useful as the base of more sophisticated operations.

The paper's main contribution lies on the careful analysis of the different
semantics of remote operations. This includes the classification of
operation types as processor-synchronous, process-synchronous, and asynchronous;
and the classification of reliability attributes (that is, the clever distinction
between semantics of 'maybe', 'at-least-once', 'only-once-type1' and
'only-once-type2' operations). There is also a discussion of how to implement
these semantics which leads to remarkable insights about the power and
limitations of general remote procedure calls.
Regarding implementation, the paper also discusses several concepts
like communication sockets for the mentioned model, and also proposes
several types of protocols suitable for efficient local network
implementation: R (request only), RR (request/reply) and RRA (request,
reply and acknowledge response). Optimization for each protocol are also

Some aspects of the methodology presented on the paper are suitable for
some criticism. For instance, the analysis methodology is rather poor,
since the model is implemented in a very specific platform (hardware dependent).
Maybe a more diverse set of implemented versions would have been useful for
a fair comparison. Additionally, it is evident that the slave protocol is not
very efficient a high loads, since the proposed implementation does not
enqueue requests (forces retransmissions). The authors seems to overlook
the importance of efficient protocols especially under non-ideal conditions
like this one (heavy network load). Conditions of heavy load are not rare;
they are easily achievable by just considering settings with several
networks RPC clients.


Evaluation of paper
"Implementing Remote Procedure Calls"
by A.D. Birrel, B.Y. Nelson

This paper describes a package providing a remote procedure call (RPC)
facility and explains some of the design ideas and decisions involved on it.
The proposed implementation provides a remote operation with a powerful
semantic (equal to a local procedure call) yet very efficient. In other words,
the semantic of a RPC is intended to emulate the semantic of a local procedure
call but (possibly) in a different machine. In order to do this, the authors
describe an implementation that utilizes four program components: the user,
the user-stub, the RPCRuntime, the server-stub and the server. The general
interaction is as follows: the 'user' program executes a procedure call
that is captured by the 'user-stub' program which encapsulate the request
and sends it to the server by using the RPCRuntime support. Upon receiving
of the request, the 'server-stub' program unpacks it and performs the
desired procedure call to the 'server' program. Potential results are
sent back using an analogous scheme.

The paper proposes two components for a successful implementation of the
system. The first one is a binding scheme, where any program may 'register'
a procedure for export (interface) and find out which processes are
exporting a given interface. This scheme is strongly based on the database
support given by Grapevine system. The second component is a very efficient
realization of the packet-level transport protocol, which is optimized
for RPC packets (for both when the case when the transferred data fits in
a single packet and when it doesn't). The resulting package (system) is
conceptually very simple, elegant, and claimed to be efficient.

One weakness of the paper is the rather sloppy performance evaluation,
since there is no evident concern about carrying out precise experiments
to determine the relevant aspects of the system (and not just a raw measurement
of some RPCs). For instance, it would be interesting to know how much of
the total RPC time corresponds to local and remote 'stub' processing.

Some aspects that deserve future research would be the support
for efficient shared memory in the system without trading the benefits
of the current RPC implementation (that is, efficient ad-hoc transport
and overall design simplicity).