将顺序代码转换为openMP并行构造

Question

I have the following piece of code that I would like to write in openmp.

My code abstractly looks like the following

I start first with dividing N=100 iterations equally among p=10 pieces and I store the allocated iterations for every piece in a vector

Nvec[1]={0,1,..,9}
Nvec[2]={10,11,..,19}
Nvec[p]={N-9,..,N}

then I loop on the iterations

for(k=0;k<p;k++){\\loop on each piece of Nvec
    for(j=0;j<2;j++){\\here is a nested loop
        for(i=Nvec[k][0];i<Nvec[k][p];i++){
            \\then I loop between the first and 
            \\last value of the array corresponding to piece k
    }
}

Now, as you can see the code is sequential with a total of 2*100=200 iterations , I wanted to parallelize it using OpenMp with the absolute condition to keep the order of iterations!

I tried the following

#pragma omp parallel for schedule(static) collapse(2)
{
for(j=0;j<2;j++){
    for(i=0;i<n;i++){
        \\loop code here
    }
}
}

this setting doesn't keep the order of the iterations as in the sequential version. In the sequential version, each chunk is processed entirely with j=0 and then entirely with j=1 .

In my openMP version, every thread takes a chunk of iterations and process it entirely with j=0 . In a way all threads treats either j=0 or j=1 cases. Every worker with p=10 processes 200/10=20 iterations , problem is all iterations are j=0 or j=1 .

How can I make sure that every thread get a chunk of iterations, performs the loop code with j=0 on all the iterations, then j=1 on the same chunk of iterations?

EDIT

what I want exactly for every chunk of 20 iterations

worker 1
j:0
i:1--->10
j:1
i:1--->10
worker p
j:0
i:90--->99
j:1
i:90--->99

the openMP code above does

worker 1
j:0
i:1--->20
worker p
j:1
i:80--->99

Answer 1

It's actually simple - just make the outer j -loop non-worksharing:

#pragma omp parallel
for (int j = 0; j < 2; j++) {
    #pragma omp for schedule(static)
    for (int i = 0; i < 10; i++) {
         ...
    }
}

If you use the static schedule, OpenMP guarantees, that each worker will get to handle the same range of i s for both j=0 and j=1 .

Note: You moving the parallel construct to the outer loop is merely an optimization to avoid thread management overhead. The code works similarly if you just place a parallel for in-between the two loops.