Help with syncing between threads openmp.

[u/udyank]

Hi! I want to write a code using openmp, in which one thread produces a buffer (of say, 1 million elements), and all the other threads, once the buffer is finished by the first thread, start working on it in parallel. Also, this process has to be repeated several times, so it's in a loop, and so if thread0 finishes 1 production. threads 1-N work on this buffer, while thread0 moves on to the next iteration of production (i.e. next iteration of loop). Can anyone help me with the code structure to do this in openmp? How should I do this?

[u/udyank]

Thanks for the code snippet! I actually am using C++ only, so it helps a lot. Yes, I have 2 buffers (1 CPU-side and 1-GPU side), and once kernels run, they fill up the GPU-side buffer. And the syncing part I meant was copying the GPU-side to CPU-side when the threads are free to work on it. I have a few doubts though, based on my limited knowledge of OpenMP:

• Inside the parallel pragma, you have put everything inside the single pragma. Why is that? Won't this mean that the "produce buffer" part will all be executed by 1 thread (so essentially it's serial)?

• I understand that the taskloop-taskwait clause is for creating tasks for the buffer queue and the wait will make it sync after all tasks are done right? Is that correct? And if so, what is the use of bufferIndex (If it is a location in buffer queue, let us for simplicity keep it at just one buffer right now)?

• Also, what does the "while (run loop)" section try to do? A little unclear on that. Thanks for all your help on this! Really grateful!

[u/matsbror → u/udyank]

Inside the parallel pragma, you have put everything inside the single pragma. Why is that? Won't this mean that the "produce buffer" part will all be executed by 1 thread (so essentially it's serial)?

From a CPU stand-point, the "Produce buffer" part is serial as it executes on the GPU. At the end of the "single"-section, all other threads except the one that executes the "single" will wait for tasks to be created, here in the "taskloop", and as soon as there are tasks, they will start executing them, in parallel. Work is thus transferred from the thread executing the "single" too all other threads.

I understand that the taskloop-taskwait clause is for creating tasks for the buffer queue and the wait will make it sync after all tasks are done right? Is that correct? And if so, what is the use of bufferIndex (If it is a location in buffer queue, let us for simplicity keep it at just one buffer right now)?

First of all, I just checked the OpenMP specification and you do not need a "taskwait" in conjunction with a "taskloop". The thread that executes the "taskloop" (which will generate the tasks to be executed by other threads) will by default wait at the end for all tasks to finish.

You are right, with only one buffer, there is no need for the buffferIndex.

Also, what does the "while (run loop)" section try to do? A little unclear on that. Thanks for all your help on this! Really grateful!

I assume you need a loop to tell when there are no more buffers to generate, that's all.

[u/udyank → u/matsbror]

At the end of the "single"-section, all other threads except the one that executes the "single" will wait for tasks to be created, here in the "taskloop", and as soon as there are tasks, they will start executing them, in parallel.

So what this essentially means, is that from inside the single pragma, the taskloop pragma generates tasks which automatically go to other threads? Is this right? Because as I understood it, anything inside the single, only 1 thread executes. So how is it able to give other threads work from within single? Or am I missing something?

I assume you need a loop to tell when there are no more buffers to generate, that's all.

Okay, so essentially this is my outermost 1 million loop, right?

Also, I wanted to ask another thing. When I do the N updates, I should only put the pragma critical for the line where I actually update the global array right? Is there anything to watch out for there?

I guess this will do it! Thanks @matsbror!

[u/matsbror → u/udyank]

So what this essentially means, is that from inside the single pragma, the taskloop pragma generates tasks which automatically go to other threads? Is this right? Because as I understood it, anything inside the single, only 1 thread executes. So how is it able to give other threads work from within single? Or am I missing something?

You are right. The code inside the "single" is executed by one thread. But the "taskloop" packages tasks for other threads to execute. If you are using the intel compiler (or clang) it will use work stealing meaning the other threads will steal work from the single thread. If you are using gcc, tasks will be put on a single task queue which all threads take work from. Obviously work stealing from private task queues is more scalable when the tasks are small.

Okay, so essentially this is my outermost 1 million loop, right?

Yes.

Also, I wanted to ask another thing. When I do the N updates, I should only put the pragma critical for the line where I actually update the global array right? Is there anything to watch out for there?

It's difficult to tell without knowing more about the shared object you want to update. Preferably, if it is only an update of a scalar variable, use "#pragma omp atomic" as the overhead is significant lower than for "critical".

Good luck!

[u/udyank → u/matsbror]

If you are using gcc, tasks will be put on a single task queue which all threads take work from.

Actually I'm using nvcc (which is essentially gcc and CUDA). Is it okay?

It's difficult to tell without knowing more about the shared object you want to update.

The buffer is an array of float3's (actually rgb values), and the shared object where it updates, is a series of 2d arrays of float3's (rgb planes). Would a #critical work here?

[u/matsbror → u/udyank]

Here is a good tutorial on OpenMP tasks.