Introduction

Presently or in the next future, high performance computing applications are bound to be built as distributed systems based on an object component architecture [4,7,9]. Some of these components may be written in data-parallel languages and run either on traditional DMP or on fast NOWs. The question of integrating such data-parallel components has been raised in multiple contexts. Java-based integration has been discussed by the Parallel Compiler Runtime Consortium [14], and implemented in the Converse framework [3]. CORBA based integration asks for describing data distribution at the IDL level, and defining efficient communication mechanisms [12].

The PPADD (Parallel Predictive-Adaptive Domain Decomposition) project is a large-scale application that naturally requires a distributed implementation on heterogeneous parallel machines. The general application field is solving PDEs through adaptive domain decomposition methods. The entry point to distributed computing is that the main computation (the solver) can see in advance that it will require some adaptation of its mesh structure, and is able to delegate these costly computations before the new data is actually required. Moreover, the solver naturally fits into the data-parallel model, while the mesh computing service is more efficiently performed on shared memory architectures.

In the development of the PPADD project, we were presented with the problem of designing both the solver and the mesh service for efficiency and reusability, and to find a smooth way of connecting the components through a LAN.

A good efficiency/reusability tradeoff for the solver was considered to be High Performance Fortran (HPF). The mesh server is written in Fortran 90. Other components, especially a visualization module, will be added later, which will use commercial tools.

We choosed to implement the coupling through Java, using the language and the various standard APIs. Smooth coupling precluded using low-level message-passing interfaces. Ideal smooth coupling would require to be able to see HPF and Fortran 90 code as object components, and to invoke remote methods from the HPF objects on the F90 objects. Java Native Interface (JNI) API allows wrapping Fortran 90 (in the limits of C-F90 interoperability, which suffer some severe restrictions), and coupling F77 with Java has been extensively studied [5,9] . The Java Remote Method Invocation (RMI) mechanism allows to inter-operate with remote Java objects. On the other hand, no standard has yet emerged for wrapping data-parallel objects. So we decided to experiment on the possibility of adapting the Java JNI and RMI both to HPF and to the requirements of our application. This paper presents a preliminary report of this experiment.

The second section describes the application, and motivates the choice of a decoupled architecture. The third section gives an overview of the architecture and points the requirements for efficiency. The following section describes the Java based implementation of components coupling. Although thoroughly tested for functionality, the architecture has not yet been tested for performance, so the next section will be the conclusion.