## Parallel Execution of Recurrences: Linear Array

This shows how
efficient prototyping of recurrences
also can utilise the processing power of parallel machines.

### Static View of Linear Array

A linear array is a computer where the processing elements are connected
in a linear fashion, i.e., each node is connected to two other nodes,
except the two end nodes which are connected to just one neighbour. The
figure shows a 16 node linear array connected computer

### Space-Time View of Linear Array

If we try to imagine how the communications of a linear array may appear
if we draw them schematically in time, we may get the following figure.

Here all the processors of the linear array are depicted at every time-step,
as if all computations where taking place instantaneously and synchronously.
The communications now go between the timesteps, to the neighbours as
defined by the static configuration of the linear array. These lines
are marked with red, diagonal lines forward in time. In addition, a processor may
retain information between computation steps. This is depicted as
a communication from a processor to itself (brown vertical lines).

### Heatflow Problem Embedded in Linear Array

The one-dimensional heatflow computation
may easily be embedded in the linear arrays computation structure.
The dependencies of this computation exhibits the same graph as the
communications of the linear array. An
animated demo
of this has been prepared as Java code.
### Butterfly Embedded in Linear Array

Butterfly computations can also be embedded
in the linear array.
This requires us to use more than one time-step for communications,
and progressively more timesteps as the communications of the butterfly
grow longer. This can be seen in the figure below, which shows a height
4 butterfly embedded in a 16 node linear array using 16 timesteps.
The scale is logarithmic in the time-direction, and the processors
have been shaded in grey when they do not compute but just forward
communications.

### The parallelisation technique

The embedding of a computation in a parallel machine over time
- maps computations to processors at specific time-steps,
- maps dependencies to paths in the parallel machine's space-time
communication structure.

The mapping is user definable and expressible as program code. This gives
the programmer full control over the computation, but still avoids lots
of detail in the writing of parallel programs.

This shows some of the potential efficient
prototyping of recurrences
has for defining parallel programs.

© 1997 Magne Haveraaen, University of Bergen, Norway.