A portable mechanism for thread persistence and migration (Mobile agent)

Previous research efforts for building thread persistence or migration systems have concentrated on the development of frameworks dealing with a small local environment controlled by a single user. In these systems, threads can only migrate between homogeneous platforms. Therefore the portability of these systems is compromised. The recent explosive growth of the Internet generates the need for applications on large-scale distributed systems. Many of these applications require certain levels of support of computational persistence or mobility. The new paradigm of distributed computing inspires research on thread persistence and migration throughout large-scale networks of heterogeneous platforms.; This dissertation proposes 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 on the Internet. Although it has become more and more widely used in modern database and distributed systems, especially Internet-oriented applications, 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, which can be restarted from exactly the same state at a later time, perhaps after migration to a new host. This technique involves introducing a new “Shutdown” exception class and wrapping each program phrase that can encounter such an exception with a handler that captures the local stack frame and then rethrows the exception. When a thread is restarted, it restores each stack frame with appropriately initialized local variables and temporaries. It then resumes forward execution at the appropriate code point. A mechanism to correctly save and restore a program's synchronization state is also described. The state externalization code is introduced into Java class files via byte code rewriting, ensuring both compiler and platform independence. Because the code to save and restore state is automatically inserted into Java byte code, the process is transparent to the application programmer.; The semantics of the externalized threads are discussed, including object sharing, boundaries of externalized and migrated 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 observed performance measures are also reported, notably in terms of code size expansion and runtime overhead introduced by postprocessing to support state saving.