Supporting Structures

Home Up Finding Concurrency Algorithm Structure Supporting Structures Implementation Mechanisms

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.

$\displaystyle \frac{T(1)}{P \; T(P)}$

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

01 June, 2004