Discover published sets by community

Purpose: Specifies a region of code that must be executed by only one thread at a time. Usage Example: #pragma omp critical {<protected code block>}

Purpose: Synchronizes all threads in a team; all must reach this point before any can proceed. Usage Example: #pragma omp parallel {<code block>} #pragma omp barrier

Purpose: Specifies the number of threads to use in a parallel region. 'n' is the number of threads. Usage Example: #pragma omp parallel num_threads(n)

Purpose: Initiates a parallel region by forking multiple threads. Usage Example: #pragma omp parallel {<code block>}

Purpose: Specifies a block of code to be run by a single thread, while others wait. Usage Example: #pragma omp parallel { #pragma omp single {<single-thread code>}}

Purpose: Sets the default data-sharing attributes for variables in a parallel region. Usage Example: #pragma omp parallel default(none)

Purpose: Declares variables to be shared across all threads in a parallel region. Usage Example: #pragma omp parallel shared(counter)

Purpose: Like private, but initializes each thread's variable with the value from the master thread. Usage Example: #pragma omp parallel firstprivate(input_data)

Purpose: Enforces memory consistency by ensuring the visibility of shared variables across threads. Usage Example: #pragma omp flush (variable)

Purpose: Removes the implicit barrier at the end of a for, single, sections or work-sharing directive. Usage Example: #pragma omp for nowait

Purpose: Divides work into separate sections that may run in parallel. Usage Example: #pragma omp parallel sections { #pragma omp section {<section code>} ... }

Purpose: In a parallel loop, assigns iterations in contiguous chunks of size 'chunk_size' to each thread ahead of time. Usage Example: #pragma omp for schedule(static, chunk_size)

Purpose: Performs a reduction on the variables using a specified operation (e.g., +, *, max, min) across threads. Usage Example: #pragma omp parallel for reduction(+:sum)

Purpose: Distributes loop iterations among threads in a parallel region. Usage Example: #pragma omp parallel for for(int i = 0; i < N; ++i) {<loop body>}

Purpose: Combines nested loops to increase the granularity of parallelism. 'n' specifies the number of loops to collapse. Usage Example: #pragma omp parallel for collapse(2) for(int i = 0; i < N; ++i) for(int j = 0; j < M; ++j){<loop body>}

Purpose: Similar to dynamic, but the size of chunks decreases over time to handle load balancing as threads become free. Usage Example: #pragma omp for schedule(guided, chunk_size)

Purpose: Creates thread-private versions of the variables for each thread in a parallel region. Usage Example: #pragma omp parallel private(x, y)

Purpose: Specifies that the enclosed loop can execute certain iterations in the original order. Usage Example: #pragma omp parallel for ordered for(int i = 0; i < N; ++i) { #pragma omp ordered {...} }

Purpose: Delegates the decision of scheduling to the compiler and runtime system. Usage Example: #pragma omp for schedule(auto)

Purpose: Creates an explicit task to be executed by any thread in the team. Usage Example: #pragma omp parallel { #pragma omp task {<code block>}}

Purpose: In a parallel loop, allows threads to request new chunks as they finish processing old ones. Usage Example: #pragma omp for schedule(dynamic, chunk_size)

Purpose: Ensures that a specific memory update operation occurs atomically. Usage Example: #pragma omp atomic {<atomic operation>}

Purpose: Designates a block to be executed by the master thread only, no barrier at the end. Usage Example: #pragma omp parallel { #pragma omp master {<master thread code>}}

Purpose: Ensures that the var from the sequentially last iteration of the loop is the one that gets written back to the global scope. Usage Example: #pragma omp for lastprivate(latest_value)

Purpose: Introduces a point at which the thread will wait for all child tasks to complete. Usage Example: #pragma omp task {<task1>} #pragma omp task {<task2>} #pragma omp taskwait