Several Java bindings to the Message Passing Interface (MPI) software have been developed for highperformance parallel Java-based computing with message-passing in the past. None of them however addressed the issue of supporting transparent Java process migration for achieving dynamic load distribution and balancing. This paper presents' a middleware, called M-JavaMPI, that runs on top of the standard JVM to support transparent Java process migration and communication redirection. The middleware allows' Java processes to freely and transparently migrate between machines to achieve load balancing, and migrated processes can continue communication with other processes using MPI. The method we use to achieve process migration is' to capture execution context and restoring the execution context at the Java bytecode level using the Java Virtual Machine Debugger Interface (JVMDI). Post-migration interprocess communication is enabled via a restorable Java-MPI API. Tests' using a 16-node cluster have shown that our mechanism yields' considerable performance gain through migration.

Grid computing o ers the perspective of solving massive computational problems using a large number of computers arranged as clusters embedded in a distributed telecommunication infrastructure. It involves sharing heterogeneous resources (based on di erent platforms, hardware/software

Abstract “Grid ” computing has emerged as an important new research field. With years of efforts, Grid researchers have successfully developed Grid technologies including security solutions, resource management protocols, information query protocols, and data management services. However, as the ultimate goal of Grid Computing is to design an infrastructure which supports dynamic, cross-organizational resource sharing, there is a need of solutions for efficient and transparent task re-scheduling in the Grid. In this research, we propose a new Grid middleware, named G-JavaMPI. This middleware adds the parallel computing capability of Java on the Grid with the support of a Grid-enabled message passing interface (MPI) for inter-process communication between Java processes executed at different Grid points. A special feature of the proposed G-JavaMPI is the support of Java process migration with post-migration message redirection. With these supports, we can migrate executing Java process from site to site for continuous computation, if some site is scheduled to turn down for system reconfiguration. The proposed middleware is useful for Grid computing, as most applications in Grid require long processing time. Restart the execution of those applications will certainly lessen the productivity. Moreover, the proposed G-JavaMPI middleware is very portable since it requires no modification of underlying OS, Java virtual machine, and MPI package. Preliminary performance tests have been conducted. The proposed mechanisms have shown good migration efficiency in a simulated Grid environment. Key Words Grid middleware MPI Java process migration 1.

We describe how complex systems of multiple BCPNN (Bayesian Confidence Propagating Neural Networks) networks are modeled, implemented and run on parallel cluster computers. The BCPNN system is modeled in terms of populations and projections. Hypercolumns and spiking activity is used to get a scalable and efficient implementation. Three communication protocols are evaluated; MPICH, TCP/IP and UDP. Fully recurrent BCPNN:s with up to 6·10 4 units that allocate more than 34 GB of memory are run. The results are that UDP provides a scalable and efficient communication protocol. The BCPNN with hypercolumns is well suited and scales well on cluster computers.

This article presents an evolution of classical SPMD programming for clusters and grids.

A metacomputer is a set of machines networked together for increased computational performance. To build an efficient metacomputer, one must assign jobs to the various networked machines intelligently. A poor job assignment strategy can result in heavily unbalanced loads and thrashing machines. This cripples the cluster's computational power. A strong job assignment strategy helps a metacomputer complete all of its jobs swiftly. Resource heterogeneity makes job assignment more complex. Placing a job on one machine might risk depleting its small memory. Another machine might have more free memory but a heavily burdened CPU. Bin packing on memory protects the system against thrashing. Load balancing protects the system against high CPU loads. Combining the two approaches, however, gives an ad hoc heuristic algorithm with no clear theoretical merit. The Cost-Benefit Framework, developed in this work, offers a new approach to job assignment on metacomputers. It smoothly handles heterogen...

Recent developments in processor capabilities, software tools, programming languages and programming paradigms have brought about new approaches to high performance computing. A steadfast component of this dynamic evolution has been the scientific community's reliance on established scientific packages. As a consequence, programmers of high-performance applications are reluctant to embrace evolving languages such as Java. This paper describes the Java-to-C Interface (JCI) tool which provides application programmers wishing to use Java with immediate accessibility to existing scientific packages. The JCI tool also facilitates rapid development and reuse of existing code. These benefits are provided at minimal cost to the programmer. While beneficial to the programmer, the additional advantages of mixed-language programming in terms of application performance and portability are addressed in detail within the context of this paper. In addition, we discuss how the JCI tool is complementing other ongoing projects such as IBM's High-Performance Compiler for Java (HPCJ) and IceT's metacomputing environment.

CCJ is a communication library that adds MPI-like collective operations to Java. Rather than trying to adhere to the precise MPI syntax, CCJ aims at a clean integration of collective communication into Java's object-oriented framework. For example, CCJ uses thread groups to support Java's multithreading model and it allows any data structure (not just arrays) to be communicated. CCJ is implemented entirely in Java, on top of RMI, so it can be used with any Java virtual machine. The paper discusses three parallel Java applications that use collective communication. It compares the performance (on top of a Myrinet cluster) of CCJ, RMI and mpiJava versions of these applications, and also compares the code complexity of the CCJ and RMI versions. The results show that the CCJ versions are significantly simpler than the RMI versions and obtain a good performance.

This paper presents a generalization of the Java Remote Method Invocation model (RMI) providing an efficient group communication mechanism for parallel programming. In our Group Method Invocation model (GMI), methods can be invoked on a local object, on a remote object or on a group of objects (possibly with personalized parameters). Likewise, result values and exceptions can be returned normally, discarded, or, when multiple results are produced, combined into a single result. The different method invocation and reply handling schemes can be combined orthogonally, allowing us to express a large spectrum of communication mechanisms of which standard RMI and MPI-style collective communication are special cases. For each method, the invocation and reply scheme can be selected at runtime. GMI has been implemented in the Manta high-performance Java system. Using several micro-benchmarks and three applications, we compare GMI's expressiveness and runtime efficiency to plain Java RMI and to the collective communication operations from the mpiJava library. Our results show that GMI significantly simplifies program complexity while our prototype implementation performs even faster than mpiJava (except for one test case). 1.

The aim of this report is to provide an introduction and overview to Java for High Performance Computing. The report will focus on performance and parallelisation- topics of considerable interest to those considering using Java for HPC. 1