OpenMP Data-Sharing Clauses: Differences Explained

1. private

• Purpose: Each thread gets its own uninitialized copy of the variable.
• Behavior:
  • The variable is undefined at the start of the parallel region.
  • Modifications by a thread are not visible to other threads or outside the parallel region.
• Use Case: When you need a thread-specific, temporary version of a variable.

---

2. shared

• Purpose: All threads share the same instance of the variable.
• Behavior:
  • Changes made by one thread are visible to all other threads.
  • Requires synchronization (e.g., critical, atomic) to avoid race conditions.
• Use Case: When threads need to collaborate on a single, shared data structure or variable.

---

3. threadprivate

• Purpose: Each thread maintains its own persistent copy of the variable across parallel regions.

• Behavior:

  • The variable must be global or static.
  • Each thread gets its own copy of the variable, which persists between parallel regions for the same thread.
  • It is uninitialized by default but can be explicitly initialized before entering a parallel region.

• Key Difference:

  • Unlike firstprivate, which initializes a thread-local copy at the beginning of a parallel region, threadprivate variables persist across multiple parallel regions, retaining thread-specific values.

• Use Case: When a thread needs its own thread-local storage across multiple parallel regions.

---

4. firstprivate

• Purpose: Each thread gets its own private copy of the variable, initialized with the value from the master thread.

• Behavior:

  • Each thread’s copy is initialized with the master thread’s value at the beginning of the parallel region.
  • Modifications made by a thread are local to that thread and do not affect other threads or persist beyond the parallel region.

• Key Difference:

  • Unlike threadprivate, the variable does not persist across parallel regions.
  • Unlike lastprivate, modifications to the variable in firstprivate do not propagate back to the master thread.

• Use Case: When a thread needs a private variable initialized with a value from the parent scope but only within a single parallel region.

---

5. lastprivate

• Purpose: Ensures that the value of the variable from the last iteration of a parallel loop is preserved and accessible after the parallel region ends.

• Behavior:

  • Each thread has a private copy of the variable, similar to private.
  • When the parallel region ends, the value from the last iteration of the loop is copied back to the variable in the master thread.
  • If the variable is used outside the loop, the final value is preserved.

• Key Difference:

  • Unlike firstprivate, the final value of the variable from the last iteration is visible outside the parallel region.
  • Unlike threadprivate, the persistence is limited to copying the value back to the master thread after the parallel region ends. It does not persist independently across threads or parallel regions.

• Use Case: When the result of the last iteration of a parallel loop is needed outside the loop.

---

Key Differences Summary

Clause	Scope	Initialization	Persistence
private	Thread-local	Uninitialized	Temporary
shared	Shared among all threads	Initialized in the master thread	Shared
threadprivate	Thread-local (global/static var)	Uninitialized (or explicitly initialized)	Persistent
firstprivate	Thread-local	Initialized from the master thread’s value	Temporary
lastprivate	Thread-local during execution	Uninitialized; copies last iteration’s value	Temporary (value propagated)