Paper evaluations for 05/17/00...

John Michael U. Datuin (jdatuin@san.rr.com)
Tue, 16 May 2000 02:02:51 -0700

The paper on "Performing Remote Operations Efficiently on a Local Computer Network"
presents a communications model which can be applied in building local computer
networks. A list of basic facilities, the techniques used to implement these facilities,
implementation considerations, and an example are also provided in the paper. The
goals of how to lower the overhead and provide a base set of language-level primitives
which can be used to create efficient, high-level primitives is what the authors tried
achieve. The authors didn't go with a layered approach in designing their communication
system, but with an integrated one for efficiency. Their aim was to provide base
primitives that would enable to create high-level functions simply and easily.
The authors presented their remote reference/remote operation model, and introduced
the regular/recoverable/communication processes. What was unclear to me was how
a recoverable process is created and used, and how it is recoverable. Also, I feel insufficient
detail was given on communication processes. I strongly feel that the paper's discussion
on the various attribute classes of a remote reference, along with their corresponding
sub-attributes (e.g., reliability attributes, operation types, synchony types, value/no value
references, etc.) complicated the understanding of references, even though the authors
were shooting for something that was understandable, simple to use, and easy to
implement. It seems that a lot of details needed to be considered before one could
go ahead and design/implement something.

The paper on "Implementing Remote Procedure Calls" was a lot more interesting
and understandable than the paper above. This paper introduces the RPC package that
was used in the Cedar environment. The main points the authors were trying to
achieve was to have clean and simple semantics, to be efficient, and to be general as
possible. According to the authors, their goal was to make it easy for distributed
computation. The paper discusses such issues as handling failures, determining the
information needed to establish a connection between caller/callee, security, as well as others.
What is interesting was that Mesa was used as the main language in the system, thus
they chose a procedure-oriented approach in designing their RPC package. Another
interesting point is their disregard for shared addresses. If I remember correctly, Pilot
was built using Mesa and it used a single address space that every process used. It
would have been interesting to know if their RPC package could have handled a
shared addressing scheme.
I don't know if I understood right, but the authors say that they have no time-out
mechanism in their RPC package since they felt that the request-response nature
of communication was sufficient. But, a little later in the paper, they said that they
used a "probe" packet that the callee is expected to acknowledge back to the caller.
Doesn't this contradict what they said that "no communications (such as "pinging"
packet exchanges) are required to maintain idle connections"? If there were no
other communications except between one caller and one callee, then when the
caller sends a request to the callee, it would have to wait for the callee's response.
During the wait, the communication would be idle. The use of the "probe" packet
seems to me that the communication isn't idle since this packet and an expected
response is being communicated between the two.
Overall, I think the RPC package presented in the paper was pretty good. It would
be interesting to know if current systems today borrowed a lot of ideas from this paper.