In this dissertation we propose a portable mechanism to support thread
persistence and migration. Neither the programming language nor the
underlying system on which the threads execute is modified. This is a general strategy to be used with different systems and applications to
facilitate their support of thread persistence or migration. The experiment was conducted on the Java programming language, a language
designed with mobile code features to be used on heterogeneous platforms. Although it has become more and more widely used in
modern database and distributed systems, Java lacks the capability to externalize a program's execution state at run time, which is essential for thread persistence and mobility.
Our system provides a way to capture, collapse and restore the execution
state of a Java thread. The saved thread can be restarted from exactly
the same state at a later time, perhaps after migration to a new host.
A mechanism to correctly save and restore a program's synchronization state
is also described. To ensure both compiler and platform independence, the
state saving code is introduced into Java class files via byte code rewriting.
The semantics of the externalized threads are discussed, including object
sharing, boundaries of object graphs, interactions with related objects,
and the circumstances under which a state saving event can be initiated.
We demonstrate the viability of our approach by describing a prototype
implementation, JThread, which includes applying the technique on
several different persistent or
mobility mechanisms to demonstrate adaptability. The performance measures are also reported, notably in terms of code size expansion and run time overhead introduced by byte code rewriting to support state saving.
The full dissertation is available in both pdf
format and postscript
My dissertation defense slides are available in powerpoint format .
My thesis proposal is available in pdf format .
The JThread package is available in a separate page .