Yang YU (yyu@cs.ucsd.edu)
Wed, 26 Apr 2000 23:11:21 -0700

1. Grapevine:
This is a paper that describes the experience working with a
operating system.
One of the main goals of the Grapevine project was to gain more
understanding on some system structures in distributed
systems. The Grapevine is mainly a message delivery system but some of
its elements can also be used for other things like file
The Grapevine is a distributed system, meaning that the service is
provided by a number of computers communicating
through an internet. It is replicated, meaning that the same service is
provided equally well by different computers.
Grapevine is a group of computers each providing two types of
service, registration service and message delivery service. The
registration service is used to map names to information about the
users, machines, services, distribution lists, and access
control lists. Then the message delivery service is used to send the
Scaling design is to increase system capacity by adding more servers
of fixed power rather than by replacing existing servers
with more powerful servers.
Transparency means that the distributed, replicated nature of the
operating system is hidden from the users.
To adjust to increased load, the authors had to change the much used
user add/delete update mechanism to be incremental
instead of copying entire lists of data. Access control and
authentication algorithms had to be changed as well.
Major contribution of this paper is that the administrators become
part of the operating system and their roles are outlined. The set-up of
the operating system is discussed and the authors try to suggest various
ways of optimized this set up. The assignment of registries to
organizational constitutents instead of geographical location is one
example of the use guidelines that the authors provide. Paying
attention to the user organization, especially in this system, is just
as important as paying attention to the advantages and disadvantages of
the implemented system.

2. Emerald
Emerald is a language and system designed for constructing
distributed programs. By fine-grained mobility, the authors refer to the
fact that small data objects as well as whole process objects can be
moved from one node to another.

Object Implementation:
The compiler implements objects in three ways: global, local, and
direct. Direct objects are the simplest; they are the
primitives (like integers) and other simple structures. Local objects
are contained within another object; they are never
referenced by any object except their enclosing object. Global objects
can be moved independently and can be referenced
globally in the network.

Finding Objects:
Each node has a hash table which records entry¡¯s for remote objects
that have a local reference, and local objects for which a remote
reference exists. If an object has moved, its reference will be a
forwarding address of the form <timestamp, node>. When an object must be
found over the network, the kernel follows the forwarding addresses
(updating its local reference at the same time) until the object is
found. If its not, then a broadcast protocol is used.

Moving Objects
The kernel handles the activation records for the objects, so that
the thread of execution is maintained across the network. It also sends
the processor registers; this is complex because the registers used by
an object can span the network, so the
activation records have special templates for the registers. Also, the
kernel translates pointers used by the objects; Emerald
uses direct memory addresses to increase performance.

Garbage collection
There are two collectors, a local collector and a distributed coll
ector. The local collector is independent of other nodes, and
can be run any time. The distributed collector was implemented such that
it could run concurrently with executing processes.

Yang Yu
Department of Computer Science and Engineering
University of California, San Diego