CSE 221: Paper evaluations

Renata C TEIXEIRA (teixeira@cs.ucsd.edu)
Wed, 26 Apr 2000 22:11:37 -0700 (PDT)

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

Grapevine is an internetwork distributed system structured according
to a client/server model. The service provided by Grapevine is divided
into a message service and a registration service. Message servers
accept messages prepared by clients for delivery to individual recipients
and distribution lists. Registration server provide naming, authentication,
access control and resource allocation functions to clients. Some clients
of Grapevine are mail system interface (which is the most used application),
file server authentication and access controls, remote-procedure call
binding and process control for an integrated circuit facility.

The registration database, which contain group entries and individual entries,
is distributed and replicated among servers at the level of an entire
registry. The system adopts a hierarchical approach to locate individuals.
This approach helps preventing scaling problems. The number of users may
grow, but the system limits the number of servers. The replication of
functions among several server is important to achieve a high reliability.
When a server fails another will continue to provide the service.

Since Grapevine is a distributed and replicated system, various issues have
to be considered as how to configure the system and how to handle
distributed servers and replicas in a transparent way for the users.
In order to reduce the load in the system the paper proposes that the most
common update messages carry only the change, which reduces the size of
the message and the computational cost for processing it; and that
interactions with file servers for authentication and access control checks
are cached in the file servers.

I think that the paper presents a complete discussion about the system, it
describes the pros and cons of Grapevine and gives interesting suggestions
to solve some of the problems found. One good feature of the system is
that it allows remote access both for users, trying to access the mail system
for instance, and for administrators, for management purposes. In addition,
the system is reliable, because of the replicated servers. The hierarchical
naming approach is a simple solution for the problem of scalability.
One drawback is that the number of servers is limited, they could have
adopted the same hierarchical approach to solve this problem.

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

Emerald is an object-oriented language and system that aims at experimenting
with the use of object mobility in distributed programming. The system runs
on local-area networks and the nodes are homogeneous.

In Emerald, objects are not members of classes/instances hierarchy, thus, each
object has its own code, which is stored on a concrete type object. When an
object is moved to another node, only its data is moved. The code is copied
only if the concrete type implementing that object is not already available on
the node. Emerald provides a set of language primitives for mobility and an
option of remote invocation that reallocates the arguments to the destination

To implement mobility of objects, Emerald compiler uses three different
styles of object implementations: global objects, which can move
independently; local objects, which are contained within another object;
and direct objects, whose data area is allocated directly in the representation
of the enclosing object. The run-time system is responsible to find objects
when need based on the forward address in the object descriptor, to extract
the state of objects to be transferred, and to perform a garbage collection
mechanism removing objects that are no longer referenced.

I think that the paper presents the system with a good level of detail. The
performance evaluation gives a quantitative view to the techniques adopted,
thereby confirming the appropriateness of these techniques. Some interesting
ideas are: to transfer of the arguments of a procedure call in a remote
invocation and to give the programmer primitives to control the mobility
of objects

Renata Teixeira