Mahim Mishra
------------
Fine Gained Mobility in the Emerald System: Jul et al.

- Mahim Mishra

This paper presents the mechanisms included in the Emerald programming
system to allow mobility of code and data objects from system to
system. Such code and data mobility allows the system to do load
blancing, improve performance by placing heavily communicating nodes
close to each other and increase availability and reconfigurability of
the system.


Some of the system's strengths are the following:

1. Compared to most other systems which migrate entire processes,
Emerald offers the fine-grained mobility of very small data and code
segments.


2. It presents uniform semantics to the programmer for local and
remote accesses, thus making the task of program development simpler.


3. In addition to moving the code, various optimizations like moving
the parameter objects have also been included to enhance performance.


In my opinion, it also suffers from some weaknesses:

1. The transfer of the data and code objects still needs manual
intervention (which the next paper fixes).


2. What will happen if a system crashes, taking down migrated objects
it is holding and rendering some if it's own objects orphans, is
unclear.


3. The functionality offered is too general and therefore increases
the complexity a lot. For computation intensive programs, more
coarse-grained approaches (again, like the next paper) would decrease
complexity considerably and probably also increase performance by
reducing book-keeping overheads.


Such a fine-grained approach for migrating computation offers an
interesting contrast to the approaches being explored today in
projects like CMU's Aura, which focus on migrating task-states rather
than application states. For example, while migrating a text editing
task, these approaches focus on migrating the text of the document and
associated formatting and settings, rather than variable and register
values. This also has the benefit of being able to use different
platforms/architectures.