Paper Evaluations: 04-26-2000

Wed, 26 Apr 2000 22:46:27 -0700 (PDT)

Title: "Experience with Grapevine: The Growth of a Distributed

This paper describes the operational experience with the Grapevine
system. Grapevine is a distributed, replicated system that provides
message delivery, naming, authentication, resource location, and
access control services in an internet of computers. Those services
are provided by each server, and they are divided in message service
and registration service.

Using the message service, a client requests the delivery of a message
to individual recipients and distribution lists. The messages are
buffered in inboxes until the recipient requests them. For reliability
and performance purposes, the inboxes of a recipient are replicated to
two or more servers. The message service uses the data provided by the
registration service. In general, the registration service provides
naming, authentication, access control and resource location function
to clients. Basically, a registration server maps names to information
about the users, machines, services, distribution lists, and access
control lists. The registration information is also replicated and the
unit of replication is the registry.

Since the description of the system was presented in a previous paper,
the interesting part of this paper refers to the evaluation of the
system based on observations of the system operation. Along with these
observations, comments about the decisions made during the design are
included, and also new features are described to correct problems
detected. The observations refer to scalability, load distribution,
reliability and remote terminal access.

In my opinion, the paper is very interesting and presents several
ideas that are applicable to modern systems. Hierarchical name
resolution is used nowadays in domain name systems, in order to
scale. Moreover, due to the widespread use of electronic mail, the
issues related to storage space used and time to process messages are
relevant to current systems. In terms of reliability, the idea of
using server replicas is used to build fault-tolerant systems.
Finally, remote terminal access both for maintenance and application
execution is adopted in most of the current systems, especially
workstations connected to the Internet.

Title: "Fine-Grained Mobility in the Emerald System"

Emerald is an object-based language and system designed for the
construction of distributed systems. The most important feature of
Emerald is the support to object migration. This approach is different
from previous systems, which support process migration, moving entire
address spaces from node to node. Hence, the main objective of Emerald
is to provide a good performance.

In order to improve performance, if an object operation is invoked,
and this object is currently present in the node, this operation is
invoked as a procedure call. Thus, kernel interventions are not
required in this case, but only if the object is present in another
node. Decisions about the migration of an object are taken by either
the compiler or the programmer. The compiler decisions are based on
the references of an object in different nodes, while the programmer
explicitly request actions related to object mobility, as move, fix,
unfix, etc. In addition, an object A can attach a object B, forcing B
to move whenever A move.

Other interesting features are the parameter-passing modes
call-by-move and call-by-visit. An invocation to a remote object using
this mode incurs in a migration of the object passed as an argument to
the node in which the invoked object currently is. In the case of a
call-by-visit, the return object is moved to the node in which the
invocation occurred.

In this system, the objects can be global, local and direct. Only
global objects can move, and hence unique global identifiers are
provided to those objects. This classification of the objects,
however, is transparent to the programmer, since there is only a
single object model.

In distributed systems built using object migration, the objects can
move from any node to any other node. Comparing to systems using RPC,
the operations invoked in a object can be executed in any node, while
RPC calls are always to the same server. Moreover, if the object is
referenced several times in a particular node, the migration of this
object to this particular node improve the response time, since it
avoids to send messages through the network to invoke an operation.
Currently, some languages, as Java, provide mechanisms for object

In my opinion, the protection provided could be improved. Protection
among objects is guaranteed by the compiler only through type checking
and run-time checks. Thus, there is no mechanism to grant access only
to a subset of objects.

--Flavio Junqueira.

Flavio Paiva Junqueira, PhD Student
Department of Computer Science and Engineering
University of California, San Diego

Office location: AP&M 4349 e-mail: