1

Suppose we have the following code schema:

main(){

   sometype data;

   #pragma omp parallel for
   for(i=0; i< n; i++){

     read data;

     do some calculations that would be used in order to update the data;

     #pragma omp critical{
        update data;
      }
   }
}

I know that we need a critical section for updating the data because two updates at the same time could lead to corruption, however what can happen if a thread is inside the critical section updating the data and another thread is trying to read the data?

I've seen some examples online where reading is considered a safe action in a multi threading system, however I'm not sure how safe it can be in the above situation. If it's not safe, what would be the appropriate action in order to make it safe?

thank you in advance

Improve this question
6
  • 1
    Reading whilst another thread is writing is never safe. Multiple readers are safe as long as they lock out all writers. Commented Apr 5, 2013 at 21:39
  • would it be possible to achieve this with openmp? How can you lock out the writers when the block where the writing occurs is somewhere else? I'm new to OpenMP and unfortunately I haven't found any example depicting this. Thanks Commented Apr 5, 2013 at 21:41
  • yes. See the answer Ixanezis provided. Commented Apr 5, 2013 at 21:44
  • 1
    While your concerns regarding thread-safety are valid (simultanious reading and writing is UB), but have you considered removing shared state at all? Depending on what your sometype is, and what update operation you do - it may be much more efficient to have private copies of data and then run reduction over them - omp parallel reduction does exactly this. It would remove contention between threads on each iteration. Commented Apr 5, 2013 at 22:30
  • The shared data is basically an unordered_map where the value is a string and the key a vector<int>. Each thread will be assigned a key and will have to read the specified vector<int> in order to check whether a computation that would eventually change the vector<int> must take place. If this computation must take place(which as I said is known after reading the specified vector<int>), then the computation by the thread is done and the vector<int> is updated. Because the whole process is rather confusing I thought about posting a simpler version of it. Commented Apr 5, 2013 at 22:49

2 Answers 2

Reset to default
2

You'll have a race condition in your example while one thread is writing (updating) data and others are reading from it. What you've read about 'reading is considered safe' refers to only simultaneous reading same data, without modifying it.

You'll have to surround your critical section with #pragma omp barriers to ensure safe update.

Consider using a #pragma omp single clause instead of #pragma omp critical if you only need one thread to update all the data. The critical section will be executed by all threads one by one.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Thank you for you answer. I have a few questions though. What does safe update mean in this case? Does it mean that if another thread reads the data the data will never be corrupt? Also is the difference between #pragma omp barrier and #pragma omp single that the former allows more threads to update the data at the same time(for example if you have an array and you want to update different cells) while the latter allows only one thread to update the data?
By safe update I mean, yes, the elimination of data corruption possibility ensuring that all threads have finished reading before your data update starts. And what do you mean by difference between #pragma omp barrier and #pragma omp single? These are just things for different purposes. barrier ensures that all threads reach the line with #pragma omp barrier first, and then continue together again. single clause allows just one thread to enter the section, others just skip it.
If your data update could be performed also in parallel, with different threads updating different cells, you do not need neither single, nor critical clause. Just split your reading and updating sections with barriers.
1

It really depends on what you are expecting to be consistent, what architecture you are running on, and what sort of updates you are making to the data.

As a rule, if you update some data in one thread, you should prevent the other thread from using or updating that data.

In typical modern processors, a single operation is only atomic when it comes to reading the input and storing the result. So, if another processor updates the same data in between the read of the input and the write of the result, the result is undefined. But the data read/written is (assuming correct alignment) will be consistent. Alignment is nearly always "correct" from the compiler, so there should be no problem with that particular piece of data. But let's say we have an array of 10 values:

10.1
10.2
10.3
10.4
10.5
10.6
10.7
10.8
10.9
11.0

And we "update" that by adding 1.0 to each value. 

11.1
11.2
11.3
11.4

---- here the other thread "interrupts" and starts using the array for its calculation"

10.5
10.6
10.7
10.8
10.9
11.0

Now, of course, the first part of the calculation will be done with "new" values, the second part with "old" values. That's probably not what you wanted.

What you won't see is a read of -1.8812121E-64 because your code read "a half-updated" value, or something like that.

Reading from many threads is safe, but as soon as any thread starts writing, you MUST make sure the other thread is not reading the data at all.

Improve this answer

1 Comment

thank you very much for your explanation, it also made things clearer to me.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.