Introduction

The SPMD (Single Program Multiple Data) programming style is the most commonly used style of writting data-parallel programs for MIMD (Multiple Instruction Multiple Data) systems. This style provides a Loosely Synchronous Model. In SPMD programming style, each processor has its own local copy of control variables and datas. Processors execute the same SPMD program asynchronously across MIMD nodes. Explicit or implicit synchronization takes place only when processors need to exchange data. Conditional branches within the source code may provide the effect of running different programs. There have been many data-parallel languages. These programming languages provided some consensus about outline of a standard language for SPMD programming. The High Performance Fortran (HPF) standard was established by the High Performance Fortran Forum in 1993. HPF is an extension of Fortran 90 to support the data-parallel programming model on distributed memory parallel computers. It extends the set of parallel features to Fortran 90. The HPF language especially targets the SPMD model. Each processor runs same program and operates on parts of the overall data. The HPF programs are simpler to write than explicit message-passing programs, but performance of HPF rarely achieves the efficiency of the message-passing. Although the HPF language might never be widely adopted, many of the ideas--for example its standardization of a distributed data model for SPMD computing--remain important. Over many years the SPMD programming style has been very popular among the high-level parallel programming environment and library developers. SPMD framework libraries try to overcome weakness of HPF. While HPF has strength on rather regular data structures and regular data access patterns problems, it is not particularly suitable for irregular data access. Some libraries are dealing directly with irregularly distributed data, DAGH [49], Kelp [27], and other libraries support unstructured access to distributed arrays, CHAOS/PARTI [21] and Global Arrays [44]. While the library-based SPMD approach to data-parallel programming may address weakness of HPF, it loses good features like the uniformity and elegance that promised by HPF. There are no compile-time or compiler-generated run-time safety checks for the distributed arrays because libraries manage the arrays. The our HPspmd model is an attempt to address such shortcomings. The HPspmd model is SPMD programming supported by additional syntax for HPF-like distributed arrays. This model provides a hybrid of the data parallel model of HPF and the low-level SPMD programming style--as often implemented using communication libraries like MPI. In the HPspmd model, a subscripting syntax can be used to directly access local elements of distributed arrays. References to these elements can only be made on processors that hold copies of the elements concerned. To ensure this, a well-defined set of rules are automatically checked by the translator. Even though the HPspmd model does provide special syntax for HPF-like distributed arrays, all access to non-local array elements should go through library function calls in the source program. These library calls must be placed in the original HPJava program by the programmer. This requirement may be unusual to people expecting high-level parallel languages like HPF, but it should not seem particularly unnatural to programmers used to writing parallel programs using MPI or other SPMD libraries. The exact nature of the communication library used is not part of the HPJava language design. Collective operations on whole distributed arrays , or some kind of get and put functions for access to remote blocks of a distributed array might be provided by an appropriate communication library. This dissertation concentrates especially on one particular communication library called Adlib. In the current system, syntax extensions are handled by a preprocessor that outputs an ordinary SPMD program in the base language. The HPspmd syntax provides a fairly thin veneer on low-level SPMD programming, and the transformations applied by the translator are correspondingly direct--only limited analysis should be needed to obtain good parallel performance. But the language does provide a uniform model of a distributed array, which can be targeted by reusable libraries for parallel communication and arithmetic. The model adopted very closely follows the distributed array model defined in the High Performance Fortran standard.