From: Richard Jackson (richja_at_expedia.com)
Date: Wed Feb 04 2004 - 17:18:05 PST
This 1988 paper by Jul, Levy, Hutchinson and Black introduces a system
called Emerald which supports very fine-grained mobility. This expands
on previous work, where only certain objects were allowed to move.
Here, a base assumption is that any object can be moved. The main
concept of a mobility-based system is that objects can be distributed
arbitrarily across the distributed system. For example, a memory
reference could actually reference the memory on another machine. Also,
this reference could change over time, as that memory was relocated to
other machines.
This paper has the following main sections: 1) Introduction to problem
domain, 2)overview of Emerald design and implementation, 3)Performance.
The first section gives a good overview of why we would even build such
a system. The general concept was strange to me, but after reading the
paper it's clear that this approach has some interesting benefits. Some
of them include: 1)load sharing, 2)communications performance,
3)availability, 4) invocation performance, 5)garbage collection. Of
these, the most interesting one was #2, as it provides some key locality
advantages. Instead of wasting resources repeatedly querying remote
data, we can transfer the data locally and use it without the network
overhead.
The second section discusses many of the issues that face a designer of
a mobility system. The main issue here seemed to be the address
translation issues or marshalling issues. That is, movement of an
object requires that all references to that object be fixed so that they
will still work after the object moves. The Emerald design solves this
by searching for references only at preemption-time, which generally
minimizes overall cost. Here, as in other parts of the paper, the
designers chose an implementation that ensures local performance is
minimally affected. This section also discusses some of the language
features that support mobility. The following primitives are
introduced: Locate, Move, Fix, Unfix, Refix. Also introduced is the
concept of "attached" objects, where movement of one object causes
attached objects to be moved as well. Using these primitives and
attachment concepts, the programmer maintains some control over the
location of objects within the system.
The section on performance described various tests that were done with
Emerald, comparing various types of remote invocation, both with and
without mobility The data showed that the mobility system actually
resulted in a speedup of 22%. Also, the authors noted that only 2 lines
of code were needed to make this improvement. This was very impressive.
Overall, Emerald seems to be a well-designed mobility system that
effectively demonstrates the power of this type of system. It
definitely changed the way I think about sharing data in a distributed
system. I think the key successes of this system were: 1) efficient
local execution, 2) ease of programming.
This archive was generated by hypermail 2.1.6 : Wed Feb 04 2004 - 17:18:17 PST