From: Manish Mittal (manishm_at_microsoft.com)
Date: Wed Feb 04 2004 - 17:33:58 PST
This paper describes Emerald, a distributed system that uses both object
based language and system facilities to support fine-grained mobility.
The objective is to get competitive performance for programs running
locally on a node as well as get standard remote execution performance.
The rest of the paper talks about the objects in Emerald, different
aspects of this language, implementation details of mobility in Emerald,
garbage collection as well as the trade-offs that the authors has faced
(for ex: generality vs performance).
Objects in Emerald contain four components, a unique network-wide name,
a representation (data local to the object), set of methods, and an
optional process. Since multiple threads of control can be active in an
object at any given time, monitors are used for synchronization. An
interesting part of Emerald is the movement of objects. The mobility of
an object in Emerald is provided by a small set of language primitives.
An Emerald object can: Locate an object, Move an object to another node,
Fix an object at a particular node, Unfix an object to make it mobile,
and Refix an object. Either the kernel or the user process can decide
when to move an object. When an object is moved, only the data is moved.
Objects without active invocations are the simplest to move. If the
pointers are present, then translation is required. For an object with
process, this involves the process's stack. When the recipient kernel
receives an object, it checks whether the object type exists locally, if
not, it obtains a copy from another node. Emerald language also provides
a primitive to allow programmers to attach objects to other objects. By
attaching the link fields, whole linked structures could be moved to
another node. This language introduces a new parameter passing
mechanism, call-by-move and call-by-visit, which is very interesting.
Also, procedure for Finding an object in Emerald is very systematic. If
the kernel has a forwarding address then it asks the specified node for
the object. Sometimes broadcast protocol is used to locate an object.
Emerald is not intended to run in large, long haul networks. The author
assumes a local area network with about 100 nodes and that these nodes
are homogeneous, run the same instruction set and are trusted. Emerald's
compiler generates templates for object data areas describing the layout
of the area. These templates are used for mobility, garbage collection
and debugging. The garbage collection scheme in Emerald is quite
impressive. The faulting garbage collection scheme that the authors have
described replaces one large delay at the start of garbage collection by
a number of smaller delays spread throughout a process' execution.
This paper was very interesting to read. Author's explanation of the
language, data translation, templates, objects and garbage collector
(local collector & faulting collection) was thorough. I found the
section on 'Moving Process Activation record' and Distributed garbage
collection difficult to understand. Also, there are some references to
other object oriented language\system such as Smalltalk & Eden which I
am not aware of. Having there understanding would have made this paper
easier to read.
This archive was generated by hypermail 2.1.6 : Wed Feb 04 2004 - 17:34:06 PST