Eu tenho um código que executa muitas iterações e somente se uma condição for atendida, o resultado da iteração será salvo. Isso é naturalmente expresso como um loop while. Estou tentando fazer o código rodar em paralelo, já que cada realização é independente. Então, eu tenho isso:

while(nit<avit){
    #pragma omp parallel shared(nit,avit)
    {
        //do some stuff
        if(condition){
            #pragma omp critical
            {
                nit++;
                \\save results
            }
        }
    }//implicit barrier here
}

e isso funciona bem ... mas há uma barreira após cada realização, o que significa que, se as coisas que estou fazendo dentro do bloco paralelo demorarem mais em uma iteração do que as outras, todos os meus encadeamentos aguardarão a conclusão, em vez de continuando com a próxima iteração.

Existe uma maneira de evitar essa barreira para que os threads continuem funcionando? Estou fazendo a média de milhares de iterações, portanto, mais algumas não machucam (caso onit variável não foi incrementada em threads já em execução) ...

Eu tentei transformar isso em um paralelo para, mas o incremento automático no loop for torna onit variável enlouquecer. Esta é a minha tentativa:

#pragma omp parallel shared(nit,avit)
{
    #pragma omp for
    for(nit=0;nit<avit;nit++){
        //do some stuff
        if(condition){
            \\save results
        } else {
            #pragma omp critical
            {
                nit--;
            }
        }
    }
}

e continua trabalhando e dando a volta no loop for, como esperado, mas meunit A variável assume valores imprevisíveis ... como se poderia esperar do aumento e diminuição dela por threads diferentes em momentos diferentes.

Eu também tentei deixar o incremento no loop for em branco, mas ele não é compilado, ou tentando enganar meu código para que não haja incremento no loop for, como

...
incr=0;
for(nit=0;nit<avit;nit+=incr)
...

mas então meu código falha ...

Alguma ideia?

obrigado

Edit: Aqui está um exemplo mínimo de trabalho do código em um loop while:

#include <random>
#include <vector>
#include <iostream>
#include <time.h>
#include <omp.h>
#include <stdlib.h>
#include <unistd.h>

using namespace std;

int main(){

    int nit,dit,avit=100,t,j,tmax=100,jmax=10;
    vector<double> Res(10),avRes(10);

    nit=0; dit=0;
    while(nit<avit){
        #pragma omp parallel shared(tmax,nit,jmax,avRes,avit,dit) private(t,j) firstprivate(Res)
        {
            srand(int(time(NULL)) ^ omp_get_thread_num());
            t=0; j=0;
            while(t<tmax&&j<jmax){
                Res[j]=rand() % 10;
                t+=Res[j];
                if(omp_get_thread_num()==5){
                    usleep(100000);
                }
                j++;
            }
            if(t<tmax){
                #pragma omp critical
                {
                    nit++;
                    for(j=0;j<jmax;j++){
                        avRes[j]+=Res[j];
                    }
                    for(j=0;j<jmax;j++){
                        cout<<avRes[j]/nit<<"\t";
                    }
                    cout<<" \t nit="<<nit<<"\t thread: "<<omp_get_thread_num();
                    cout<<endl;
                }
            } else{
                #pragma omp critical
                {
                    dit++;
                    cout<<"Discarded: "<<dit<<"\r"<<flush;
                }
            }
        }
    }
    return 0;
}

Eu adicionei ousleep parte para simular um segmento levando mais tempo que os outros. Se você executar o programa, todos os threads precisarão aguardar o término do thread 5 e, em seguida, iniciarão a próxima execução. o que estou tentando fazer é precisamente evitar essa espera, ou seja, eu gostaria que os outros threads escolhessem a próxima iteração sem esperar pela conclusão de 5.