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.

Increasing interest is being shown in the use of Java for large scale or Grande applications. This new use of Java places specific demands on the Java execution environments that can be tested using the Java Grande benchmark suite [5], [6], [7]. The large processing requirements of Grande applications makes parallelisation of interest. A suite of parallel benchmarks has been developed from the serial Java Grande benchmark suite, using three parallel programming models: Java native threads, MPJ (a message passing interface) and JOMP (a set of OpenMP-like directives). The contents of the suite are described, and results presented for a number of platforms.

This paper describes a software architecture that allows image processing researchers to develop parallel applications in a transparent manner. The architecture's main component is an extensive library of low level image processing operations that can be run on distributed memory MIMD-style parallel hardware. Since the library has an application programming interface identical to that of an existing sequential image library, all parallelism is completely hidden from the user. In this paper we give an overview of all architecture components, and show how issues related to automatic parallelization and optimization are dealt with by the application of domain specic performance models. Results obtained for a realistic application indicate that model-based optimization of a wide range of imaging software indeed is possible. 1

We outline an extension of Java for programming with distributed arrays. The basic programming style is Single Program Multiple Data (SPMD), but parallel arrays are provided as new language primitives. Further extensions include three distributed control constructs, the most important being a data-parallel loop construct. Communications involving distributed arrays are handled through a standard library of collective operations. Because the underlying programming model is SPMD programming, direct calls to MPI or other communication packages are also allowed in an HPJava program.

This paper analyzes the overheads incurred in the exploitation of loop-level parallelism using Java Threads and proposes some code transformations that minimize them. Avoiding the intensive use of Java Threads and reducing the number of classes used to specify the parallelism in the application results in promising performance gains that may encourage the use of Java for exploiting loop-level parallelism. On average, the execution time for our synthetic benchmarks is reduced by 50 % from the simplest transformation when 8 threads are used. The paper explores some possible enhancements to the Java threading API oriented towards improving the application{runtime interaction. 1.

Abstract not found

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...

In current Java implementations, Remote Method Invocation is slow. On a Pentium Pro/Myrinet cluster, for example, a null RMI takes 1228 µs using Sun's JDK 1.1.4. This paper describes Manta, a Java system designed to support efficient communication. On the same Myrinet cluster, Manta achieves a null RMI latency of 35 µs. Manta is based on a native Java compiler. It achieves high communication performance mainly through the following techniques: removal of copying in the network sub system, compiler-generation of specialized marshaling code, and Optimistic Active Messages, a technique that avoids thread creation in message handlers for small methods. Our work shows that techniques from other high performance RPC based systems also work in Java, making RMI, originally designed for distributed programming, a viable mechanism for parallel programming as well. 1 Introduction There is a growing interest in using Java for high-performance parallel applications (see, for example, the Java Gran...

Java is increasingly popular as a programming language for highperformance computation. This is because it is a modern, accessible language that is expressive enough for large classes of applications. However, since Java was originally not designed for high-performance computation, It is not surprising that some significant improvements in expressiveness and efficiency are possible by augmenting the language with constructs that address the needs of high-performance programs. We have designed

As a relatively straightforward object-oriented language, Java is a plausible basis for a scientific parallel programming language. We outline a conservative set of language extensions to support this kind of programming. The programming style advocated is Single Program Multiple Data (SPMD), with parallel arrays added as language primitives. Communications involving distributed arrays are handled through a standard library of collective operations. Because the underlying programming model is SPMD programming, direct calls to other communication packages are also possible from this language.