F--: A Simple Parallel Extension to Fortran 90

[David G Hough at validgh]

The September 1997 SIAM News contains an interesting article on F--, an
extension to Fortran 90 for distributed-memory parallel programming, by
Robert Numrich (rwnacray.com) and Jon Steidel (jlsacray.com).    I am indebted
to Bodo Parady for bringing it to my attention (information overload is getting
pretty bad when I don't even read the front page headlines of SIAM News 
consistently).    

The significance of the proposal is that a single syntactic extension to
Fortran (and perhaps with analogous extensions to C++ and Java)
expresses much parallel programming far more clearly than the principal
current paradigms represented by comment-like compiler directives and large
subroutine libraries like MPI.    One might still use an MPI library to
implement the message passing implicit in the F--, but MPI would no longer
be explicitly on the programmer's mind.

I haven't done any distributed-data parallel programming, so I can't judge
very well the completeness of the proposal, and I would welcome discussion
from numeric-interest people who can so judge.

I don't know if a copy of the proposal is available online, but the idea
in a nutshell is that distributed data is declared with statements like

	real a(1024) [4,4]

and accessed with expressions like

	a(i) [j,k]

Here a is an array of 16384 elements distributed across 16 logical processors
which the programmer has chosen to think of as a 4 x 4 array.    Data references
without the square brackets are to local data; with the square brackets are
to data associated with other logical processors and perhaps implicitly invoke
an MPI call if the logical processors are actually distributed physically.
Read the SIAM News for more details.

Thinking about other languages, I think a different syntax might be more
economical intellectually, e.g.

	real a(1024) a (4,4)
	a(i) a (j,k)

and perhaps easier to read, but the details of the syntax aren't as interesting
to me as the question of whether the expressive power is sufficient to handle
the requirements of most numerical distributed-memory programming jobs 
without additional calls to MPI or compiler directives.