The HPJava Language

HPJava [#!HPJava!#] is an instance of the HPsmpd language model. HPJava extends its base language, Java, by adding some predefined classes and some additional syntax for dealing with distributed arrays.

As explained in the previous section, the underlying distributed array
model is equivalent to the HPF array model. Array mapping
is described in terms of a slightly different set of basic
concepts. *Process group* objects generalize the processor
arrangements of HPF. *Distributed range* objects are used
instead HPF templates. A distributed range is comparable with a single
dimension of an HPF template. These substitutions are a change
of parameterization only. Groups and ranges fit better with our
distributed control constructs.

Figure 3.1 is a simple example of an HPJava program. It
illustrates creation of distributed arrays, and access to their
elements. The class `Procs2` is a standard library class derived
from the special base class `Group`. It represents a
two-dimensional grid of processes. Similarly the distributed range class
`BlockRange` is a library class derived from the special class `Range`; it denotes a range of subscripts distributed with
BLOCK distribution format over a specific process dimension. Process
dimensions associated with a grid are returned by the `dim()`
inquiry.
The `on(p)` construct is a new control construct specifying that
the enclosed actions are performed only by processes in group `p`.

The variables `a`, `b` and `c` are all distributed array
objects. The type signature of an -dimensional distributed array
involves double brackets surrounding comma-separated slots. The
constructors specify that these all have ranges `x` and `y`--they
are all `M` by `N` arrays, block-distributed over `p`.

A second new control construct, *overall*, implements a
distributed parallel loop. The constructs here iterates over all
locations (selected by the degenerate interval ``` : `

'') of
ranges `x`

and `y`

. The symbols `i` and `j` scoped
by these constructs are called *distributed indices*. In HPF, a
distributed array element is referenced using integer subscripts, like
an ordinary array. In HPJava, with a couple of exceptions noted
below, the subscripts in element references must be distributed
indices, and these must be bound by an overall construct to a location
in the range associated with the array dimension. This rather drastic
restriction is a principal means of ensuring that referenced array
elements are held locally.

The general policy is relaxed slightly to simplify coding of stencil
updates. A subscript can be a *shifted location*. Usually
this is only legal if the subscripted array is declared with suitable *ghost regions* [#!Ghost!#]. Figure 3.2 illustrates the
use of the library class `ExtBlockRange` to create arrays with
ghost extensions (in this case, extensions of width 1 on either side of
the locally held ``physical'' segment). The communication library
routine `Adlib.writeHalo` updates the ghost region. This example
also illustrates application of a postfix back-quote operator to a
distributed index . The expression `i`` (read ``i-primed'')
yields the integer global loop index.

Distributed arrays can be defined with some sequential dimensions. The sequential attribute of an array dimension is flagged by an asterisk in the type signature. As illustrated in Figure 3.3, element reference subscripts in sequential dimensions can be ordinary integer expressions.

The short examples here have already covered much of the special syntax
of HPJava. Other significant extensions allow Fortran-90-like *sections* of distributed arrays. This, in turn, forces us to define
certain *subranges* and *subgroups*. Arrays constructed
directly using subgroups and subranges can reproduce all the alignment
options of HPF. In any case, the language itself is relatively
simple. Complexities associated with varied and irregular patterns of
communication are dealt with in libraries. These can implement many
richer operations than the `writeHalo` and `cshift` functions
of the examples.