OpenMP task firstprivate-CodePudding

I have a question regarding the OpenMP task pragma, if we suppose the following code:

#pragma omp parallel
{
 x = omp_get_thread_num();

#pragma omp task firstprivate(x)
//do something with x

}

as far as I understood tasking, it is not guaranteed, which thread executes the task. So my question is, is "x" in the task now the id of thread generated the task or the one who executes it?

e.g. if thread 0 comes across the task, and thread 3 executes it: x should be 0 then, right?

CodePudding user response：

So my question is, is "x" in the task now the id of thread generated the task or the one who executes it?

It depends, if the parallel default data-sharing attribute is shared (which by default typically it is) then:

'x' can be equal to any thread ID ranging from 0 to the total number of threads in the team - 1. This is because there is a race condition during the update of the variable 'x'.

This can be show-cased with the following code:

#include <omp.h>
#include <stdio.h>
int main(){
    int x;
    #pragma omp parallel
    {
        x = omp_get_thread_num();

        if(omp_get_thread_num() == 1){
                sleep(5);
                #pragma omp task firstprivate(x)
                {       
                   printf("Value of x = %d | ID Thread executing = %d\n", x, omp_get_thread_num());
                }
        }

    }
    return 0;
}

So the thread with ID=1 creates the task, however, 'x' can have different values than '1' and also different values than the thread currently executing the task. This is because while the thread with ID=1, is waiting during sleep(5);, the remaining threads in the team can update the value of 'x'.

Typically, the canonical form in such use-cases would be to use a single pragma wrapping around the task creation as follows:

#include <omp.h>
#include <stdio.h>
int main(){
    int x;
    #pragma omp parallel
    {
        #pragma omp single
        {
                printf("I am the task creator '%d'\n", omp_get_thread_num());
                x = omp_get_thread_num();
                #pragma omp task firstprivate(x)
                {       
                        printf("Value of x = %d | ID Thread executing = %d\n", x, omp_get_thread_num());
                }
        }

    }
    return 0;
}

And in this case as @Michael Klemm mentioned on the comments:

..., x will contain the ID of the thread that created the task. So, yes, if thread 0 created the task, x will be zero even though thread 3 is picked to execute the task.

This also applies in the cases that variable 'x' is private by the time the statement x = omp_get_thread_num(); happens.

Therefore, if you run the code above you should always get I am the task creator with the same value as Value of x =, but you can get a different value in ID Thread executing. For example:

I am the task creator '4'
Value of x = 4 | ID Thread executing = 7

This is in accordance to the behaviour specified in the OpenMP standard, namely:

The task construct is a task generating construct. When a thread encounters a task construct, an explicit task is generated from the code for the associated structured block. The data environment of the task is created according to the data-sharing attribute clauses on the task construct, per-data environment ICVs, and any defaults that apply.

The encountering thread may immediately execute the task, or defer its execution. In the latter case, any thread in the team may be assigned the task.