paper evaluations: 04/27

Alejandro Hevia (ahevia@cs.ucsd.edu)
Thu, 27 Apr 2000 04:33:11 -0700 (PDT)


Evaluation of paper
"Experience with Grapevine: The Growth of a Distributed System"
by M.D. Schroeder, A.D. Birrel and R.M. Needham

The paper analyzes the operation of an existent distributed system, Grapevine,
in a large and practical environment. The system provides a distributed
and replicated messaging system, including naming, resource allocation and
access control services. A good support to user interaction to messages,
and system scalability, availability and reliability are the main goals
of the analyzed system.

The authors discuss remarkably well the effect of a large number of users
on the system and how small design decisions may turn to be system bottlenecks.
Among particularly interesting problems discussed are performance issues of
distributing mails for long (and possibly nested) distribution lists, the
increasing flow of mails among far away nodes (and how multistep forwarding
improves efficiency and robustness under unreliable links), and the different
tradeoffs between safety and higher communication bandwidth (or update delays)
when control data (registries) are replicated.

Nevertheless, many of the paper's suggestions are based on only quantitative
empirical evidence, and hence, it is not clear whether some of the solutions
can be extrapolated to other distributed systems.

One interesting aspect of the paper is that it cleverly introduces solutions
to several (currently standard) issues presented in both e-mail server
configuration and network topology design (like mailing groups and recursive
mail aliasing, distributed mail delivery, replication of services and space
distribution organized under domain names - registry -).

Some proposed open problems/issues are collecting reliable statistics
(particularly about resource usage per user) and the implementation of mail
servers that actually store user mail and allow reading of any random piece
of mail through interactive user terminals.

------------------------------------------

Evaluation of paper
"Fine-Grained Mobility in the Emerald System"
by E. Jul, H. Levy, K. Hutchinson, A. Black.

The paper describes an object-oriented language and a system that support
object mobility, that is, where objects (containing data as well as processes)
can dynamically move to a different node if needed. Object migration is supported
by implementing remote procedure calls where any data object referenced by the
procedure can be moved into the node executing the procedure (technically, the
system implements the semantics of "call-by-object-reference", in particular
"call-by-move", that is, object finally remains in node, and "call-by-visit",
where object returns to caller's node after the call).

Much of the motivation of this paper is based on providing efficient and flexible
support for mobile objects and, at the same time, obtain very efficient local
access. As any system that implements distributed data, solutions are proposed to
deal with problems like translation of references (disambiguation of non-local
references and conversion of mobile references, in particular, including detecting
references stored in activation records and processor registers) and
concurrent global garbage collection.

The scheme proposed in this paper is evaluated by comparing it with a system
that does not implement mobile objects, that is, where all references are
explicitly resolved by message queries to the object's owner. The results
show that this scheme reduces network traffic and application elapsed time.
Nevertheless, this result implicitly assumes the network be the bottleneck
of accessing remote data; it would be interesting to know how much of the
analysis stands when the computing speed (relative to network speed) becomes
the decisive factor.

On the other hand, the main contribution of the paper is to propose a scheme
that allows migration of individual objects instead of whole processes.
This opens the door to a novel paradigm of data sharing since references are
now dynamically disambiguated (and no data copy by using messages is needed)
allowing a much more flexible scheme to reference data either locally or
on the network.