OpenMP: Introduction to OpenMP (Part 10)

Introduction to OpenMP Reduction

OpenMP (Open Multi-Processing) is a popular API for shared-memory parallel programming. One of the key features of OpenMP is reduction, which allows you to perform parallel reductions on a set of variables. Reduction is particularly useful when you need to compute the sum, product, maximum, minimum, or any other associative operation on a set of values.

The reduction construct in OpenMP simplifies the process of parallel reduction by automatically dividing the work among multiple threads and combining the results at the end. It reduces the complexity of parallel reduction implementation, allowing you to focus on the algorithmic logic instead.

Syntax of OpenMP Reduction

The syntax of the reduction construct in C++ using OpenMP is as follows:

        
            #pragma omp parallel for reduction(operator: variable)
            for (int i = 0; i < num_iterations; ++i) {
                // loop body
            }
        
    

In the above syntax:

• #pragma omp parallel for indicates that the following loop should be parallelized among multiple threads.
• reduction(operator: variable) specifies the reduction operation and the variable to be reduced.
• operator is the reduction operator, such as + for addition, * for multiplication, max for maximum, min for minimum, etc.
• variable is the variable that will store the result of the reduction.

Example of OpenMP Reduction

Let's consider an example where we want to compute the sum of an array using OpenMP reduction. Here's how you can do it:

        
            #include <iostream>
            #include <omp.h>

            int main() {
                const int size = 100;
                int arr[size];

                // Initialize the array with values
                for (int i = 0; i < size; ++i) {
                    arr[i] = i + 1;
                }

                int sum = 0;

                #pragma omp parallel for reduction(+: sum)
                for (int i = 0; i < size; ++i) {
                    sum += arr[i];
                }

                std::cout << "Sum: " << sum << std::endl;

                return 0;
            }
        
    

In the above example, we initialize an array arr with values from 1 to 100. We then use OpenMP reduction to compute the sum of the array elements by parallelizing the loop. The reduction operation + is applied to the sum variable.

Operator and Initial Value Table

Here's a table that shows some commonly used operators and their corresponding initial values for reduction in OpenMP:

Operator	Initial Value
+	0
*	1
max	Minimum value
min	Maximum value