
\section*{Introduction}

     For several years it has been widely acknowledged that the route
to very high performance computing is through parallel processing.
Today it seems that individual processors are approaching their
technological limits, and the most straightforward way to surpass those
limits is by allowing many processors to cooperate on a single task.

     ``Parallel computers'' of one kind or another have been on the
market for over a decade.  The spectrum of machines is very
broad.  At one extreme there are tightly coupled systems involving
thousands of very specialised ``processing elements''---individually,
hardly recognisable as computers.  At the opposite extreme, local area
networks of ordinary workstations can be programmed to cooperate on
single tasks, and to this extent qualify as parallel computers.
Somewhere in between are systems built from microprocessors specially
designed to support parallel computing; and systems built around more
or less conventional processors, with attached co-processors, switching
circuits, shared memory sub-systems, etc, to support very high
bandwidth communication amongst the processors.

     This divervity of architectures is a big headache for
the programmer.  Arguably, this is why parallel machines do not yet
dominate the market for high performance computers.
The problem is that a program written for one
brand of parallel computer may not run at all on another manufacturer's
machine.  Even if you stick with the same manufacturer,
their next generation machine may look completely different,
and your code may have to changed to exploit the new hardware.

     Eventually it may happen that one architecture emerges as
the de facto standard, and all manufacturers produce variations on that
theme.  To some extent this has happened with sequential computers.  To
a larger extent, the portability of sequential code can be attributed
to the fact that all manufacturers provide compilers for the standard
high-level languages.  These conceal differences between their
processors at the instruction level (even for sequential computers
assembly-language programs are not portable).  It does not seem to
be possible to take the standard sequential languages and compile
them to execute efficiently on parallel computers.  But the precedent
does suggest that the way forward in parallel computing may be to
develop standard {\em parallel} languages which can be compiled to run
on a wide range of architectures.

     This development started already with the establishment of the
Fortran 90 standard.  Fortran 90 is the successor to Fortran 77.  From
the parallel programming point of view, it is interesting because it
includes a set of array operations which can be used to express
parallel algorithms.  Fortran 90 is still quite conservative so
far as parallel extensions are concerned.

     In the last year the {\em High Performance Fortran Forum},
a coalition of many leading industrial and academic groups in the
field of parallel processing, has established an informal language
standard called {\em High Performance Fortran\/} (HPF).  It is based on
Fortran 90, but extends the set of parallel features, and provides
extensive support for computation on {\em distributed memory} parallel
computers.  The standard is supported by a majority of vendors of
parallel hardware, including Cray, DEC, Fujitsu, HP, IBM, Intel,
Maspar, Meiko, nCube, Sun and Thinking Machines.  Several companies have
already announced their intention to develop HPF implementations,
including hardware vendors DEC, Intel, Maspar, Meiko, Thinking
Machines, and compiler vendors ACE, APR, KAI, Lahey, NA Software,
Portland and PSR.

      An official subset of HPF has been defined to facilitate early
implementations.  It is expected that the first true {\em Subset HPF}
implementations will appear at the end of 1993 or start of 1994.

     This document is an introduction to data parallel programming
in Fortran 90 and High Performance Fortran.
It is {\em not} an exhaustive or unbiased description
of either of the two languages.  It concentrates on a few interesting
aspects of the languages, and illustrates how to program in them.

     Part I concentrates on how parallelism is expressed in the
languages.  Part II describes the HPF model of distributed data.

