Our HPJava language incorporates some ideas from High Performance Fortran (HPF) , and also from lower level library-based SPMD approaches, including MPI. The principles of HPF are not adopted wholesale in HPJava. Instead we import a just subset of basic HPF language primitives into HPJava: in particular distributed arrays. Although distributed arrays appear as language primitives--the better to support development of libraries operating on distributed data--the actual programming model is not the single-threaded model of HPF. Instead it is direct SPMD programming. Library-based SPMD programming has been very successful in its domain of applicability, and is well-established. We can assume fairly confidently that the lessons and successes of SPMD programming will carry over HPJava. What it is less obvious is that HPJava can provide acceptable performance at each computing node.
There are two reasons why HPJava node performance is uncertain. The first one is that the base language is Java. We believe that Java is a good choice for implementing our HPspmd model. But, due to finite development resources, we can only reasonably hope to use the available commercial Java Virtual Machines (JVMs) to run HPJava node code. HPJava is, for the moment, a source-to-source translator. Thus, HPJava node performance depends heavily upon the third party JVMs. Are they good enough?
The second reason is related to nature of the HPspmd model itself. The data-distribution directives of HPF are most effective if the distribution format of arrays (``block'' distribution format, ``cyclic'' distribution and so on) is known at compile time. This extra static information contributes to the generation of efficient node code2.
HPJava starts from a slightly different point of view. It is primarily intended as a framework for development of--and use of--libraries that operate on distributed data. Even though distributed arrays may be clearly distinguished from sequential arrays by type signatures, their distribution format is typically not known in advance (at compile time). Instead distribution format is described by several objects associated with the array--collectively the Distributed Array Descriptor. This makes the implementation of libraries simple and natural. But, can we still expect the kind of node performance possible when one has detailed compile-time information about array distribution?
We begin to address these questions in this paper with benchmarks for some simple but relevant algorithms. These algorithms will be benchmarked, comparing the output of current HPJava compiler--which is quite general but not yet particularly efficient--and also with the same code modified by applying some straightforward optimizations that we intend to add to the translator in the near future. We will compare with C++, Fortran and ordinary Java versions of the same algorithms. For now the HPJava versions are executed on a single processor. But--because of the way the translation scheme works--we are reasonably confident that the similar results will carry over to node code on multiple processors.