cse 221: paper evals

Octavian Luca (oluca@cs.ucsd.edu)
Thu, 27 Apr 2000 03:15:44 -0700 (PDT)


This paper discusses Grapevine, an distributed, replicated system that
provides messaging services for an so-called internet of computers. The
discussion focuses on its features of message delivery, naming,
authentication, resource location, and access control as well as what the
researchers have learned from using it. This paper is important because
its discussion of grapevine reveals many issues pertinent distributed
systems design.

The goal of the project was to provide a messaging system for a group of
computers that are part of an organization. The network is made up of
client workstations and servers that provide messaging and registration
services. Messages are buffered on server inboxes until clients request
them. The registration service provides the other functions mentioned
above based on a registration database used for controlling the messaging
service. Both services are distributed accross all the servers by
duplicating similar functionality accross all servers. However, the
contents of the inboxes are not duplicated from server to server, rather
servers tend to hold information belonging to their closest clients. The
code run on the clients implements the internet protocols for
communicating with particular Grapevine servers, and performes the
resource location required to choose which server to contact for a
particular function.

The researchers try to analize the effects of scale on this system.
Successful scaling is considered to be the ability to increase system
capacity by adding more servers of fixed power rather than through the use
of increasingly powerful servers. To interpret progress towards this goal
they theorize that one should be able to measure the total load placed on
the system by a particular community, know how much load a single server
should carry, and then be abel to compute the number of servers required
by performing simple division. Using this methodology they were able to
identify problems and improve the resource location algorithm, as well as
improve scaling capabilities by dividing the registration database into
registries. By observing user trends, they were also able to more
effectively handle system-wide interest lists through the addition of
indirection to their interpretation. The overall feel of the system was
reanalized, and problems were revealed in the way registrations were
propagated accross the distributed system that appeared monolithic to
inidvidual users.

This paper revealed what are some of the important issues in the design of
distributed systems and what are some possible avenues of evaluating
system performance to identify potential scaling trouble spots. Their
approach seemed to identify the major trouble spots and the solutions
proposed seemed to solve the problems. However, it seems that their
approach does not completely guarantee successful scaling, but rather
iterative adaptations for supporting increased system loads.


The authors of this paper describe Emerald, an object-based language and
system designed for the construction of distributed programs. Emerald is
based on goals of supporting fine-grained object mobility, and the paper
presents implementation details used to facititate this. Similarly to the
paper on Grapevine, this paper is important because its discussion of
Emerald reveals many issues pertinent distributed systems design. This
work is different from others previously studied in this class in it's
focus on facilities for building distributed systems, and evaluating and
selecting appropriate approaches for solving problems arising from
distributing systems.

The researchers approached building this system by first creating a
programming language which inherently supports a distributed system's need
for mobility, distribution and abstract types. The authors successfuly
demonstrate that as opposed to process mobility, the overhead
of Emerald objects is commensurate with their complexity, thus providing
an efficient way to transfer fine-grained data from node to node. Object
invocation is location independent, but language primitives are provided
for determining and manipulating the location of objects. Remote
invocation of objects is optimized by allowing users to declare attached
varibles as a method of grouping related objects together so that on a
remote invocation they are moved together, thus mimimizing node
communication overhead. By providing programmers with a parameter passing
mode named call-by-move, Emerald permits an invocation's argument object
to be moved with the invocation request. Ohter noteworthy features are
the use of a single shared address space per node to eliminates
unnecessary overhead in node structures.

The methodology used was to optimize the design by making common system
opperations fast at the expense of other less common ones. Thus local
invocations are speeded up at the expense of remote invocations. The
authors prove that their assumptions are valid by providing data which
supports their design decisions. From this paper i learned yet another
way of structuring a distributed system, and what additional issues are to
be considered when designing such a system.