Importance of Node Performance

Our HPJava language incorporates some ideas from High Performance Fortran (HPF) [22], and also from lower level library-based SPMD approaches, including MPI. All principles of HPF are not adopted wholesale in HPJava. Instead we import just a subset of basic HPF language primitives into HPJava: in particular distributed arrays. 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 code. 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 often not known in advance (at compile time). Can we still expect the kind of node performance possible when one does have detailed compile-time information about array distribution? We begin to address these questions in this chapter with benchmarks for some applications mentioned earlier. These applications will be benchmarked, comparing the output of current HPJava compiler. In this chapter these applications 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. In fact this will be confirmed in the next chapter.