atomic inside a single construct

Question

In an openMP framework, suppose I have a series of tasks that should be done by a single task. Each task is different, so I cannot fit into a #pragma omp for construct. Inside the single construct, each task updates a variable shared by all tasks. How can I protect the update of such a variable?

A simplified example:

#include <vector>

struct A {
  std::vector<double> x, y, z;
};

int main()
{
  A r;
  #pragma omp single nowait
  {
    std::vector<double> res;
    for (int i = 0; i < 10; ++i)
      res.push_back(i);
    // DANGER
    r.x = std::move(res);
  }
  #pragma omp single nowait
  {
    std::vector<double> res;
    for (int i = 0; i < 10; ++i)
      res.push_back(i * i);
    // DANGER
    r.y = std::move(res);
  }
  #pragma omp single nowait
  {
    std::vector<double> res;
    for (int i = 0; i < 10; ++i)
      res.push_back(i * i + 2);
    // DANGER
    r.z = std::move(res);
  }
  #pragma omp barrier

  return 0;
}

The code lines below // DANGER are problematic because they modify the memory contents of a shared variable. In the example above, it might be that it still works without issues, because I am effectively modifying different members of r. Still the problem is: how can I make sure that tasks do not simultaineusly update r? Is there a "sort-of" atomic pragma for the single construct?

Answer 1

There is no data race in your original code, because x,y, and z are different vectors in struct A (as already emphasized by @463035818_is_not_a_number), so in this respect you do not have to change anything in your code.

However, a #pragma omp parallel directive is missing in your code, so at the moment it is a serial program. So, it should look like this:

  #pragma omp parallel num_threads(3)
  {
    #pragma omp single nowait
    {
        std::vector<double> res;
        for (int i = 0; i < 10; ++i)
        res.push_back(i);
        // DANGER
        r.x = std::move(res);
    }
    #pragma omp single nowait
    {
        std::vector<double> res;
        for (int i = 0; i < 10; ++i)
        res.push_back(i * i);
        // DANGER
        r.y = std::move(res);
    }
    #pragma omp single nowait
    {
        std::vector<double> res;
        for (int i = 0; i < 10; ++i)
        res.push_back(i * i + 2);
        // DANGER
        r.z = std::move(res);
    }
  }

In this case #pragma omp barrier is not necessary as there is an implied barrier at the end of parallel region. Note that I have used num_threads(3) clause to make sure that only 3 threads are assigned to this parallel region. If you skip this clause then all other threads just wait at the barrier.

In the case of an actual data race (i.e. more than one single region/section changes the same struct member), you can use #pragma omp critical (name) to rectify this. But keep in mind that this kind of serialization can negate the benefits of multithreading when there is not enough real parallel work beside the critical section.

Note that, a much better solution is to use #pragma omp sections (as suggested by @PaulG). If the number of tasks to run parallel is known at compile time sections are the typical choice in OpenMP:

#pragma omp parallel sections 
{
   #pragma omp section 
   {
     //Task 1 here
   }
   #pragma omp section
   {
     //Task 2 
   }
   #pragma omp section
   {
     // Task 3
   }
}

For the record, I would like to show that it is easy to do it by #pragma omp for as well:

 #pragma omp parallel for 
 for(int i=0;i<3;i++)
 {
    if (i==0)
    {
       // Task 1
    } else if (i==1)
    {
       // Task 2 
    }
    else if (i==2)
    {
       // Task 3
    }
 }