Dynamic reconfiguration in distributed systems: adapting software modules for replacement

Hofmeister, Christine; Purtilo, James M.

doi:10.1109/icdcs.1993.287718

Cited by 53 publications

(31 citation statements)

References 6 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…Application mobility can be used to dynamically balance the load between several machines in a distributed system [38,20], to reduce network traffic by moving clients closer to servers [16], to dynamically reconfigure distributed applications [24], to implement mobile agent platforms [41,11], to tackle user nomadism in mobile computing environments [3], or as a machine administration tool [39]. Application persistence can be used for fault tolerance [26,48] or for application debugging.…”

Section: Introductionmentioning

confidence: 99%

Experiences implementing efficient Java thread serialization, mobility and persistence

Bouchenak¹,

Hagimont²,

Krakowiak³

et al. 2004

Softw Pract Exp

View full text Add to dashboard Cite

SUMMARYToday, mobility and persistence are important aspects of distributed computing. They have many fields of use such as load balancing, fault tolerance and dynamic reconfiguration of applications. In this context, Java provides many useful mechanisms for the mobility of code via dynamic class loading, and the mobility or persistence of data via object serialization. However, Java does not provide any mechanism for the mobility/persistence of computation (i.e., threads). We designed and implemented a new mechanism, called Java thread serialization, that is used to build thread mobility or thread persistence. Therefore, a running Java thread can, at an arbitrary state of its execution, migrate to a remote machine where it resumes its execution, or be checkpointed on disk for possible subsequent recovery. With our services, migrating a thread is simply performed by the call of our go primitive, and checkpointing/recovering a thread is performed by the call of our store and load primitives. Several projects have recently addressed the issue of Java thread serialization, e.g., Sumatra, Wasp, JavaGo, Brakes, JavaGoX, Merpati. Some of them have attempted to minimize the overhead incurred by the thread serialization mechanism on thread performance, but none of them has been able to completely avoid this overhead. We propose a generic Java thread serialization mechanism that does not impose any performance overhead on serialized threads. This is achieved thanks to the use of type inference and dynamic de-optimization techniques. In this paper, we describe the design and implementation details of our thread serialization prototype in Sun Microsystems' JDK. We report on experiments conducted with our prototype, present a comparative performance evaluation of the main thread serialization techniques, and confirm the elimination of the performance overhead with our thread serialization mechanism.

show abstract

Section: Introductionmentioning

confidence: 99%

Experiences implementing efficient Java thread serialization, mobility and persistence

Bouchenak¹,

Hagimont²,

Krakowiak³

et al. 2004

Softw Pract Exp

View full text Add to dashboard Cite

show abstract

“…One of the most common approaches is represented by an environment or middleware with native adaptation capabilities. Examples include Conic [80], Polylith [81], 2K / dynamicTao [82] and many others; they all offer a set of dynamic adaptation primitives as a premium for applications built with and operating on top of themselves. Georgia Tech [83] defines a concept called service morphing, which refers to dynamic service assembly, deployment, and coordination.…”

Section: Related Workmentioning

confidence: 99%

Retrofitting Autonomic Capabilities onto Legacy Systems

et al. 2006

View full text Add to dashboard Cite

Autonomic computing-self-configuring, self-healing, self-managing applications, systems and networks-is a promising solution to ever-increasing system complexity and the spiraling costs of human management as systems scale to global proportions. Most results to date, however, suggest ways to architect new software designed from the ground up as autonomic systems, whereas in the real world organizations continue to use stovepipe legacy systems and/or build "systems of systems" that draw from a gamut of disparate technologies from numerous vendors. Our goal is to retrofit autonomic computing onto such systems, externally, without any need to understand, modify or even recompile the target system's code. We present an autonomic infrastructure that operates similarly to active middleware, to explicitly add autonomic services to pre-existing systems via continual monitoring and a feedback loop that performs reconfiguration and/or repair as needed. Our lightweight design and separation of concerns enables easy adoption of individual components for use with a variety of target systems, independent of the rest of the full infrastructure. This work has been validated by several case studies spanning multiple real-world application domains.

show abstract

“…Generic (i.e. non necessarily process-based) examples of dynamic adaptation middleware include, Conic [14], Polylith [12], 2K / dynamicTao [13] and many others; they all offer a set of dynamic adaptation primitives as a premium for applications built with and operating on top of themselves. Also many of the works that use process technology for SW control and coordination adopt in fact a middleware-like approach, by exerting the coordination "from the inside", that is, on the target's own computations.…”

Section: Related Workmentioning

confidence: 99%