Introduction to OpenMP (part 1)¶

Objectives

Learn about the parallel construct.
Learn about data sharing rules.

OpenMP (Open Multi-Processing) is a programming API for shared-memory parallel programming in C, C++, and Fortran languages. It is based on pragmas or directives which augment the source code and change how a compiler processes the source code. In case of OpenMP, the pragmas specify how the code is to be parallelized.

Important

The Kebnekaise login and compute nodes have the OMP_NUM_THREADS environmental variable set to 1 by default.

If you are using the Kebnekaise login nodes to experiment with OpenMP, then it is important to set the OMP_NUM_THREADS environmental variable to some reasonable value:
$ export OMP_NUM_THREADS=8
Please note that you are not allowed to run long computations on the login nodes!
If you are using the Kebnekaise compute nodes to experiment with OpenMP, then either unset the OMP_NUM_THREADS environmental variable:
```
$ unset OMP_NUM_THREADS
```
or, if you specified the --cpus-per-task=<cpu count> SLURM argument, set the OMP_NUM_THREADS environmental variable to the number of CPU cores available for the task:
$ export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK

Simple example¶

Consider the following “Hello world” program:

#include <stdio.h>

int main() {
    printf("Hello world!\n");
    return 0;
}

We can confirm that the code indeed behaves the way we expect:

$ gcc -o my_program my_program.c -Wall
$ ./my_program
Hello world!

Let us modify the program by adding an OpenMP pragma:

#include <stdio.h>

int main() {
    #pragma omp parallel
    printf("Hello world!\n");
    return 0;
}

This time the program behaves very differently (note the extra -fopenmp compiler option):

$ gcc -o my_program my_program.c -Wall -fopenmp
$ ./my_program
Hello world!
Hello world!
...
Hello world!

Clearly, the omp parallel pragma caused the program to execute the printf line several times. If you go and try to execute the program on a different computer, you will observe that the number of lines printed is the same as the number of processor cores in the computer. The -fopenmp compiler option tells the compiler to expect OpenMP pragmas.

Challenge

Compile the “Hello world” program yourself and try it out.
See what happens if you set the OMP_NUM_THREADS environmental variable to different values:

$ OMP_NUM_THREADS=<value> ./my_program

What happens? Can you guess why?

Solution

Let us try values 1, 4 and 8:

$ OMP_NUM_THREADS=1 ./my_program
Hello world!
$ OMP_NUM_THREADS=4 ./my_program
Hello world!
Hello world!
Hello world!
Hello world!
$ OMP_NUM_THREADS=8 ./my_program
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!
Hello world!

The “Hello world!” line is printed 1, 4 and 8 times. The OMP_NUM_THREADS environmental variable sets the default team size (see below).

OpenMP pragmas and constructs¶

In C and C++, an OpenMP pragma has the following form:

#pragma omp directive-name [clause[ [,] clause] ... ] new-line

A compiler typically supports several types of pragmas, not just OpenMP pragmas. Therefore, all OpenMP pragmas begin with the keywords #pragma omp. The directive-name placeholder specifies the used OpenMP construct (e.g. parallel) and a pragma is always followed by a new line. Typically, a pragma affects the user code that follows it but some OpenMP pragmas are stand-alone. You can span a pragma across multiple lines by using a backslash (\ ) immediately followed by a new line:

#pragma omp directive-name \
    [clause[ [,] \
    clause] ... ] new-line

Parallel construct¶

In the earlier example, we used the parallel pragma:

#pragma omp parallel [clause[ [,] clause] ... ] new-line
    structured-block

The pragma creates a team of OpenMP threads that executes the structured-block as a parallel region:

The structured-block region can be a single statement, like in the earlier example, or a structured block consisting of several statements:

#pragma omp parallel ...
{
    statement1;
    statement2;
    ...
}

OpenMP guarantees that all threads in the team have executed the structured block before the execution continues outside the parallel region.

The behaviour of a parallel construct can be modified with several clauses:

if([parallel :] scalar-expression)
num_threads(integer-expression)
default(shared | none)
private(list)
firstprivate(list)
shared(list)
copyin(list)
reduction([reduction-modifier ,] reduction-identifier : list)
proc_bind(master | close | spread)
allocate([allocator :] list)

We will return to some of these clauses later but for now it is sufficient to know that a parallel construct can be selectively enabled/disabled with the if clause and the size of the team can be explicitly set with the num_threads clause.

Challenge

Modify the following program such that the printf line is executed only twice:

#include <stdio.h>

int main() {
    #pragma omp parallel
    printf("Hello world!\n");
    return 0;
}

Hint: Each thread in the team executes the structured block once.

Solution

Use the num_threads clause to set the team size to two:

#include <stdio.h>

int main() {
    #pragma omp parallel num_threads(2)
    printf("Hello world!\n");
    return 0;
}

$ gcc -o my_program my_program.c -Wall -fopenmp
$ ./my_program
Hello world!
Hello world!

Explicit data sharing rules¶

The default behaviour can be changed with the default clause:

#include <stdio.h>

int main() {
    int number = 1;
    #pragma omp parallel default(none)
    printf("I think the number is %d.\n", number++);
    return 0;
}

This tells the compiler that a programmer must explicitly set the data sharing rule for each variable. It is therefore not surprising that the compiler produces an error indicating that the number variable is not specified in the enclosing parallel region:

$ gcc -o my_program my_program.c -Wall -fopenmp
my_program.c: In function ‘main’:
my_program.c:6:5: error: ‘number’ not specified in enclosing ‘parallel’
    6 |     printf("I think the number is %d.\n", number++);
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
my_program.c:5:13: error: enclosing ‘parallel’
    5 |     #pragma omp parallel default(none)
      |

We can now set the number variable to firstprivate:

#include <stdio.h>

int main() {
    int number = 1;
    #pragma omp parallel default(none) firstprivate(number)
    printf("I think the number is %d.\n", number++);
    return 0;
}

It is generally recommended that a programmer sets the data sharing rules explicitly as this forces them to think about the data sharing rules. It is also advisable to declare all private variables inside the structured block.

Challenge

Fix the following program:

#include <stdio.h>

char *str = "I think the number is %d.\n";

int main() {
    int initial_number = 1;

    #pragma omp parallel
    int number = initial_number;
    printf(str, number++);

    return 0;
}

Use explicit data sharing rules.

Solution

#include <stdio.h>

char *str = "I think the number is %d.\n";

int main() {
    int initial_number = 1;

    #pragma omp parallel default(none) shared(str, initial_number)
    {
        int number = initial_number;
        printf(str, number++);
    }

    return 0;
}

First, we add the enclosed { } brackets thus making the number variable private. Next, we use default(none) to force explicit data sharing rules. Finally, we declare the str and initial_number variables shared as none of the threads modify these variables.

$ gcc -o my_program my_program.c -Wall -fopenmp
$ ./my_program
I think the number is 1.
I think the number is 1.
I think the number is 1.
...

It is also possible to declare the variables str and initial_number as firstprivate. However, the creation of private variables causes some overhead and it is therefore generally recommended that variables that can be declared shared are declared as shared.

Introduction to OpenMP (part 1)¶

Simple example¶

OpenMP pragmas and constructs¶

Parallel construct¶

Data sharing rules¶

Explicit data sharing rules¶