فروشگاه و مرجع فایل و پروژه های دانشگاهی

عنوان: چند مقاله زبان اصلی درباره سیستم های توزیع شده JVM

نوع فایل: PDF

تعداد فایل ها: 4 فایل

تعداد صفحات: 300 صفحه

حجم فایل: 1.55 مگابایت

لیست عناوین فایل ها:

1. Distributed Java Virtual Machine
2. Distributed JVM
3. Java Distributed System: Developer Manual
4. Distributed Java Virtual Machine with Thread Migration

چکیده ای از هر مقاله:

1. Abstract

Because Java has a built-in support for multi-threading and thread-synchronisation, parallel Java applications that are traditionally executed on a single Java Virtual Machine (JVM) can be constructed easily. Because of the emergence of cluster computing that are a cost-eective substitute for multi-core computers, there have been dierent approaches for developing a distributed runtime environment to run Java application in parallel.
In this thesis we added a distributed runtime system to an open-source JVM called Jikes Research Virtual Machine to provide a true parallel execution environment for multi-threaded Java applications within a cluster of workstations. To achieve transparency, we implemented a virtual global object space to hide the underlying distribution from the programmer and the application. Supplementarily, we added mechanisms for accessing objects in this global memory space, thread synchronization, distributed classloading, distributed scheduling and nally for I/O redirection and evaluated the overhead of these mechanisms with several microbenchmarks.
The result is a prototype of a distributed Java Virtual Machine running as part of the JikesRVM which oers a wide scope for extensions. By embedding the virtual object heap into the JVM and making the JVM aware of the cluster, the distributed runtime system benets from the abundant runtime information of the JVM which gives the opportunity for further optimizations.

2. Abstract

A Java virtual machine (JVM) provides an abstraction of the underlying operating system and the hardware. This makes it possible to implement a distributed JVM (dJVM) which is transparent to the user application. Transparency means that the application is unable to determine whether it is running on a traditional JVM or a dJVM. Such a system is also known as a single system image (SSI). A dJVM has the advantage of providing a user application with the computing performance of a cluster.
This thesis describes the implementation of ColoJVM, which is a dJVM based on the Jikes RVM [4]. The implementation distributes newly created threads to remote nodes. The SSI property is then fullled by the implementation of a global heap which manages and distributes objects shared between multiple nodes. In addition the ColoJVM must provide functionality to synchronize classloading on the cluster, to perform locking on shared objects, to redirect system calls and to perform garbage collection.
The result of the thesis is a prototype system able to run basic test programs. The implementation of the prototype led to insights into the challenges faced by extending a meta-circular JVM. Based on the prototype system a set of common distributed JVM operations have been benchmarked.

3. Abstract

A distributed Java platform has been designed and built for the simplified implementation of distributed Java applications. Its programmable nature means that code as well as data is distributed over a network. The generality of the system is demonstrated through the emulation of a MIMD (multiple instruction, multiple data) architecture. One of the key features of our system is that it can dynamically alter the size of work units to achieve the optimal processing time per unit. The user of the system is only required to extend 2 Java classes to fully implement a distributed computation. This manual and the supporting webpage give all of the information required to completely design, compile, and test such a computation so that it can be run on the distributed system.

4. Abstract of thesis entitled
“Distributed Java Virtual Machine with Thread Migration”
submitted by Wenzhang Zhu
for the degree of Doctor of Philosophy
at the University of Hong Kong in August 2004

Recent advances in better Java class libraries and Just-in-Time (JIT) compilation techniques have greatly improved the performance of Java to match that of C/C++. To fully exploit Java’s multithreading feature on clusters, an attractive goal is to extend the Java Virtual Machine (JVM) to be “cluster-aware” so that a group of JVMs running on distributed nodes can work together as a single, more powerful JVM to support true parallel execution of a multithreaded Java application. In a cluster-aware JVM, the Java threads created within one program can run on different cluster nodes to achieve a higher degree of execution parallelism. The distributed system would provide all the virtual machine services to Java programs, and should be fully compliant with the Java language specification. We refer to such a distributed system as a Distributed JVM (DJVM).
In our study, we solve the problem of transparent Java thread migration in a JIT-enabled DJVM. The problem of thread migration is to suspend a running thread in a multithreaded application on one node, and resume its execution on a target node, such that the thread continues to execute and communicate with other threads of the same application on different nodes. In this act, the challenges lie in dealing with different types of pointers associated with the context of the migratory thread. The JIT compilation in JVM has made the native code of Java methods be dynamically placed, thus the method pointer relocation becomes difficult. Shared Java objects i
must continue to be valid after thread migration, which calls for proper and efficient memory consistency protocol in DJVM. The Java thread stack of the migratory thread also imposes difficulty when it is relocated on the target node.
Our study provides a new thread migration methodology by using JIT compilers to tackle the above pointer problem. The native code instrumentation approach and the JIT recompilation approach are proposed to transform the native thread context into a portable thread context that can be used to efficiently relocate different types of pointers during thread migration. To support the validity of object pointers after migration, we propose a global object space (GOS) embedded in DJVM that can provide a single system image (SSI) illusion to Java threads. This study presents the design, implementation, and analysis of our DJVM named JESSICA2. We provide indepth study on thread migration, as well as the optimization on distributed object sharing in DJVM based on Java memory model. Performance study
has confirmed the efficiency of thread migration in JESSICA2.