|
The Finding
Concurrency and Algorithm
Structure design spaces focus on algorithm
expression. At some point, however, algorithms must be
translated into programs. The patterns in the Supporting
Structures design space address that phase of the
parallel program design process, representing an intermediate
stage between the problem-oriented patterns of the Algorithm
Structure design space and the specific
programming mechanisms described in the Implementation
Mechanisms design space. We call these patterns Supporting
Structures since they describe software constructions or
``structures'' that support the expression of parallel
algorithms. An overview of this design space and its place in
the pattern language is shown in the figure.
The patterns fall into two groups
| Program
structuring patterns
| SPMD
The interactions between the various units of
execution (UEs) cause most of the problems when
writing correct and efficient parallel programs. How
can programmers structure their parallel programs to
make these interactions more manageable and easier to
integrate with the core computations? |
| Master/Worker
How should a program be organized when the design is
dominated by the need to dynamically balance the work
on a set of tasks among the units of execution? |
| Loop Parallelism
Given a serial program whose runtime is dominated by a
set of computationally intensive loops, how can it be
translated into a parallel program? |
| Fork/Join
In some programs, the number of concurrent
tasks varies as the program executes, and the way
these tasks are related prevents the use of simple
control structures such as parallel loops. How can a
parallel program be constructed around such
complicated sets of dynamic tasks? |
|
| Patterns
representing data structures
| Shared Data
How does one explicitly manage shared data inside a
set of concurrent tasks? |
| Shared Queue
How can concurrently-executing units of
execution (UEs) safely share a queue data structure? |
| Distributed Array
Arrays often need to be partitioned between multiple
units of execution. How can we do this so as to obtain
a program that is both readable and efficient? |
|
| Other Supporting Structures
In addition to the supporting structure patterns included
in our pattern language, the literature of parallel
computing includes a number of less commonly used
supporting structures. We describe some of the more
important ones in our book including: SIMD (Single
Instruction Multiple Data), MPMD (Multiple Program,
Multiple Data), client server, declarative parallel
programming languages, problem solving environments |
|