Ajents: towards an environment for parallel, distributed and mobile Java applications

Izatt, Matthew; Chan, Patrick; Brecht, Tim

doi:10.1002/1096-9128(200007)12:8<667::aid-cpe504>3.0.co;2-u

Cited by 31 publications

(23 citation statements)

References 4 publications

(1 reference statement)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…• A shared object system, e.g., Ajents [29] and Javanaise [22]. The latter project is a Java distributed replicated object system, where synchronization of replicas is based on the entry consistency protocol [5].…”

Section: Thread Serialization Object Serializationmentioning

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: Thread Serialization Object Serializationmentioning

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

“…project tries to ease parallel programming in Java using parallel and distributed frameworks [Launay and Pazat 1998]. Ajents is a Java system that supports object migration [Izatt et al 1999]. Several Java-based programming systems also exist for developing wide-area metacomputing applications [Alexandrov et al 1997;Baldeschwieler et al 1996;Christiansen et al 1997].…”

Section: Fast Communication Systemsmentioning

confidence: 99%

Efficient Java RMI for parallel programming

2001

ACM Trans. Program. Lang. Syst.

View full text Add to dashboard Cite

Java offers interesting opportunities for parallel computing. In particular, Java Remote Method Invocation (RMI) provides a flexible kind of remote procedure call (RPC) that supports polymorphism. Sun's RMI implementation achieves this kind of flexibility at the cost of a major runtime overhead. The goal of this article is to show that RMI can be implemented efficiently, while still supporting polymorphism and allowing interoperability with Java Virtual Machines (JVMs). We study a new approach for implementing RMI, using a compiler-based Java system called Manta. Manta uses a native (static) compiler instead of a just-in-time compiler. To implement RMI efficiently, Manta exploits compile-time type information for generating specialized serializers. Also, it uses an efficient RMI protocol and fast low-level communication protocols.A difficult problem with this approach is how to support polymorphism and interoperability. One of the consequences of polymorphism is that an RMI implementation must be able to download remote classes into an application during runtime. Manta solves this problem by using a dynamic bytecode compiler, which is capable of compiling and linking bytecode into a running application. To allow interoperability with JVMs, Manta also implements the Sun RMI protocol (i.e., the standard RMI protocol), in addition to its own protocol.We evaluate the performance of Manta using benchmarks and applications that run on a 32-node Myrinet cluster. The time for a null-RMI (without parameters or a return value) of Manta is 35 times lower than for the Sun JDK 1.2, and only slightly higher than for a C-based RPC protocol. This high performance is accomplished by pushing almost all of the runtime overhead of RMI to compile time. We study the performance differences between the Manta and the Sun RMI protocols in detail. The poor performance of the Sun RMI protocol is in part due to an inefficient implementation of the protocol. To allow a fair comparison, we compiled the applications and the Sun RMI protocol with the native Manta compiler. The results show that Manta's null-RMI latency is still eight times lower than for the compiled Sun RMI protocol and that Manta's efficient RMI protocol results in 1.8 to 3.4 times higher speedups for four out of six applications.

show abstract

“…Although there are many systems providing customized class loaders to satisfy application-specific requirements [3,6], we do not know about any efforts to develop an architecture that would be generic and customizable enough to be reusable across different systems.…”

Section: Related Workmentioning

confidence: 99%

Flexible Class Loader Framework: Sharing Java Resources in Harness System

Kurzyniec

Sunderam

2001

Computational Science — ICCS 2001

View full text Add to dashboard Cite

Abstract. Harness is a Java-centric, experimental metacomputing system based on the principle of dynamic reconfigurability, not only in terms of the computers and networks that comprise the virtual machine, but also in the capabilities of the VM itself. These characteristics may be modified under user control via a "plug-in" mechanism that is the central feature of the system. This "plug-in" mechanism relies on the underlying class loader services which enable loading and accessing Java classes and resources from a set of software repositories. However, the specific class loading requirements imposed by Harness cannot be satisfied by any of the class loaders provided as a part of Java platform. In this paper we describe new, flexible, class loading techniques which are primarily intended to improve plug-in management and security aspects in the Harness system but can also benefit other applications, especially those collaboratively accessing shared Java resources.

show abstract

Ajents: towards an environment for parallel, distributed and mobile Java applications

Cited by 31 publications

References 4 publications

Experiences implementing efficient Java thread serialization, mobility and persistence

Experiences implementing efficient Java thread serialization, mobility and persistence

Efficient Java RMI for parallel programming

Flexible Class Loader Framework: Sharing Java Resources in Harness System

Contact Info

Product

Resources

About