Java's threads offer appropriate means either for parallel programming of SMPs or as target constructs when compiling add-on features (e.g. forall constructs, automatic parallelization, etc.) Unfortunately, Java does not provide elegant and straightforward mechanisms for parallel programming on distributed memory machines, like clusters of workstations. JavaParty transparently adds remote objects to Java purely by declaration while avoiding disadvantages of explicit socket communication, the programming overhead of RMI, and many disadvantages of the message-passing approach in general. JavaParty is specifically targeted towards and implemented on clusters of workstations. It hence combines Java-like programming and the concepts of distributed shared memory in heterogeneous networks.

This paper proposes a system named Addistant, which enables the distributed execution of "legacy" Java bytecode. Here "legacy" means the software originally developed to be executed on a single Java virtual machine (JVM). For adapting legacy software to distributed execution on multiple JVM, developers using Addistant have only to specify the host where instances of each class are allocated and how remote references are implemented. According to that specification, Addistant automatically transforms the bytecode at load time. A technical contribution by Addistant is that it covers a number of issues for implementing distributed execution in the real world. In fact, Addistant can adapt a legacy program written with the Swing library so that Swing objects are executed on a local JVM while the rest of objects are on a remote JVM.

To ease the task of programming parallel and distributed applications, the Do! project aims at the automatic generation of distributed code from multi-threaded Java programs. We provide a parallel programming model, embedded in a framework that constraints parallelism without any extension to the Java language. This framework is described here and is used as a basis to generate distributed programs.

Java provides a clean object-oriented programming model and allows for inherently systemindependent programs. Unfortunately, Java has a limited concurrency model, providing only threads and remote method invocation (RMI). The JR programming language extends Java to provide a rich concurrency model, based on that of SR. JR provides dynamic remote virtual machine creation, dynamic remote object creation, remote method invocation, asynchronous communication, rendezvous, and dynamic process creation. JR’s concurrency model stems from the addition of operations (a generalization of procedures) and JR supports the redefinition of operations through inheritance. JR programs are written in an extended Java and then translated into standard Java programs. The JR run-time support system is also written in standard Java. This paper describes the JR programming language and its implementation. Some initial measurements of the performance of the implementation are also included.

This paper presents a new approach to improve execution-time performance of Java programs by extending the superthreaded speculative execution model [16, 17, 18] to exploit coarse-grained parallelism on a shared-memory multiprocessor system. The parallelization model, called Java Speculative MultiThreading (JavaSpMT), combines control speculation with run-time dependence checking to parallelize a wide variety of loop constructs, including do-while loops, that cannot be parallelized using standard parallelization techniques. JavaSpMT is implemented using the standard Java multithreading mechanism and the parallelization is expressed using a Java source-to-source transformation. Thus, the transformed programs are still portable to any shared-memory multiprocessor system with a Java Virtual Machine implementation that supports native threads. The performance of the JavaSpMT model is evaluated on an 8-processor shared-memory node of an IBM SP system using the AIX4.3.2 implementation of JDK-I.I.6 with JIT compilation and three Java application programs.

The performance of Java just-in-time compilers currently approaches native C++, making Java a serious contender for supercomputing application development. This paper presents DOGMA#a new Java based system which enables parallel computing on heterogeneous computers. DOGMA supports parallel programming in both a traditional message passing form and a novel object-oriented approach. DOGMA provides support for dedicated clusters as well as idle workstations through the use of a web basedbrowse-in feature or the DOGMA screen saver. This research provides a uni#ed environment for developing high performance supercomputing applications on heterogeneous systems. 1 Introduction Researchers have long soughttointegrate the computational power of heterogeneous clusters of computers in order to achieve fault tolerance, utilization of idle computers and resource sharing. Unfortunately, the complexity of heterogeneous computing has made these goals elusive. The Java programming language has elimin...

Networks of workstations are a dominant force in the distributed computing arena, due primarily to the excellent price/performance ratio of such systems when compared to traditionally massively parallel architectures. It is therefore critical to develop programming languages and environments that can potentially harness the raw computational power availab le on these systems. In this article, we present JavaNOW (Java on Networks of Workstations), a Java based framework for parallel programming on networks of workstations. It creates a virtual parallel machine similar to the MPI (Message Passing Interface) model, and provides distributed associative shared memory similar to Linda memory model but with a flexible set of primitive operations. JavaNOW provides a simple yet powerful framework for performing computation on networks of workstations. In addition to the Linda memory model, it provides for shared objects, implicit multithreading, implicit synchronization, object dataflow, and collective communications similar to those defined in MPI. JavaNOW is also a component of the Computational Neighborhood [63], a Java-enabled suite of services for desktop computational sharing. The intent of JavaNOW is to present an environment for parallel computing that is both expressive and reliable and ultimately can deliver good to excellent performance. As JavaNOW is a work in progress, this article emphasizes the expressive potential of the JavaNOW environment and presents preliminary performance results only.

. Parallel languages are tools for constructing efficient application programs, while reducing the required labor. In this light, using the most appropriate tool for each component of a complex system seems natural, resulting in multi-paradigm multilingual programming. The Converse system developed at Illinois addresses the issues involved in supporting multilingual applications. This paper describes the development of a large parallel application in Computational Biophysics from the point of view of multilingual programming. NAMD, a molecular dynamics program, is implemented using three different "paradigms": Parallel message-driven objects, Message-Passing, and Multithreading. The issues faced in implementing such a system, and the advantages of multilingual approach are discussed. NAMD is already operational on many parallel machines. Some preliminary performance results are presented and the lessons learned from this experience are discussed. 1 Introduction Parallel programming co...

We describe a native-code implementation of Java that supports distributed objects. In order to foster the correctness of distributed programs, remote access is syntactically and semantically indistinguishable from local access. This transparency is provided by the runtime system through the implicit generation of remote references to an object when it is passed as an argument or returned from a remote method call. Consistency is achieved through the use of a distributed (and thus scalable) global addressing scheme. Experiments show that application performance is a function of data layout, access algorithm, and local workload. For distributed applications, such as distributed databases, these factors may not be known statically, suggesting the importance of runtime support.

Abstract. The Converse run-time framework was designed with dual objectives: that of supporting quick development of portable run-time systems for new parallel programming paradigms, and that of permitting interoperability between multi-paradigm modules in a single application. This paper reports on the re nements made to the original Converse model since its inception almost two years ago, and assesses our experience in using Converse to satisfy the above objectives. A brief overview of the motivation and overall design of Converse is included for completeness. Extensions and re nements in Converse are discussed along with the reasons for their inclusion. Several languages/paradigms were implemented using Converse; techniques used in these implementations and our experience with speci c features of Converse used in them are discussed. A major multilingual multi-paradigm parallel application developed within the Converse framework is described. 1