This design space is under construction. Most of these patterns will be replaced soon..

Intent:

The patterns at this level support design activities in the ImplementationMechanisms design space.

Also Known As:

Motivation:

The ImplementationMechanisms design space is concerned with how the patterns of the higher-level spaces are mapped into particular programming environments. We use it to provide pattern-based descriptions of common mechanisms for process/thread management (e.g., creating or destroying processes/threads) and process/thread interaction (e.g., monitors, semaphores, barriers, or message-passing). Patterns in this design space, like those in the SupportingStructures design space, describe entities that strictly speaking are not patterns at all. As noted previously, however, we include them in our pattern language to provide a complete path from problem description to code, and we document them using our pattern notation for the sake of consistency.

Applicability:

These patterns are meant to be used in implementing patterns in higher-level design spaces.

Structure:

The following is a list of patterns in this space, organized according to the type of coordination event. This set of patterns is not unique; we try here to balance completeness and convenience.

• Process Management.

• Fork/join.
• SPMD.
• Remote procedure call.

• Synchronization.

• Barriers.
• Locks.
• Semaphores (binary and counting).

• Serialization.

• Critical sections.
• Monitors.

• Asynchronous control.

• Future variables
• Condition variables.
• Active messages.
• Asynchronous events (signals, callbacks, etc.).
• Single-assignment variables.

• Communication.

• Message passing (send/receive)
• Collective communication.
• Reductions.

Usage:

Patterns in this space are linked to patterns in higher design spaces: They are usually used to implement patterns in the AlgorithmStructure design space and the SupportingStructures design space.

Consequences:

Since most of these patterns relate to low-level coordination events, their consequences tend to be localized to a small part of the problem.

Implementation:

The implementation of these patterns will vary greatly depending on the environment. Most of them correspond to primitives in one or more parallel programming environments. Since it is sometimes desirable, however, to use one of these patterns in an implementation based on some programming environment that does not provide a corresponding primitive, we try to indicate how each pattern can be implemented in terms of other primitives.

Examples:

Known Uses:

Every parallel programming environment uses a subset of these patterns. Examples of their use, therefore, are everywhere.

Related Patterns: