 | Finding Concurrency
This design space is concerned with structuring the problem to expose exploitable concurrency. The designer working at this level focuses on high-level algorithmic issues and reasons about the problem to expose potential concurrency.
|
| Algorithm Structure
This design space is concerned with structuring the algorithm to take advantage of
potential concurrency. That is, the designer working at this level reasons about how
to use the concurrency exposed in working with the Finding Concurrency patterns. The Algorithm Structure patterns describe overall strategies for
exploiting concurrency.
|
| Supporting Structures
This design space represents an intermediate stage between the Algorithm Structure
and Implementation Mechanisms design spaces. Two important groups of patterns
in this space are those that represent program-structuring approaches and those that
represent commonly used shared data structures.
|
| Implementation Mechanisms
The Implementation Mechanisms design space is concerned with how the
patterns of the higher-level spaces are mapped into particular programming
environments. We use it to provide descriptions of common mechanisms for
process/thread management and interaction. The items in this design space are not
presented as patterns since in many cases they map directly onto elements within
particular parallel programming environments. We include them in our pattern language
anyway, however, to provide a complete path from problem description to code.
 | Introduction to Implementation Mechanisms |
| UE Management
 | Thread Creation/Destruction |
| Process Creation/Destruction |
|
| Synchronization
| Memory Synchronization and Fences |
| Barriers |
| Mutual Exclusion |
|
| Communication
| MPI: Message Passing |
| OpenMP: Message Passing |
| Java: Message Passing |
| Collective Communication |
| Other Communication Constructs |
|
|
