omp parallelo vs. omp parallelo

Question

Qual è la differenza tra questi due?

[A]

#pragma omp parallel
{ 
    #pragma omp for
    for(int i = 1; i < 100; ++i)
    {
        ...
    }
}

[B]

#pragma omp parallel for
for(int i = 1; i < 100; ++i)
{
   ...
}

Answer 1

Non credo che ci sia alcuna differenza, uno è una scorciatoia per l'altro. Anche se l'implementazione esatto può trattare con loro in modo diverso.

  

I costrutti condivisione del lavoro parallelo combinati sono una scorciatoia per   specificando un costrutto parallelo contenente un costrutto worksharing   e non altre dichiarazioni. clausole consentite sono l'unione delle clausole   consentito per i costrutti paralleli e condivisione del lavoro.

http://www.openmp.org/mp- documenti / OpenMP3.0-SummarySpec.pdf

Le specifiche per OpenMP sono qui:

https://openmp.org/specifications/

Answer 2

Queste sono equivalenti.

#pragma omp parallel genera un gruppo di fili, mentre #pragma omp for divide iterazioni tra le filettature generati. È possibile fare entrambe le cose in una sola volta con la direttiva #pragma omp parallel for fuso.

Answer 3

Ecco esempio di utilizzo parallel separati e for qui . In breve può essere utilizzato per l'allocazione dinamica di OpenMP array filiformi privato prima dell'esecuzione del ciclo for in diversi thread. E 'impossibile fare la stessa cosa di inizializzazione in caso parallel for.

UPD: Nell'esempio questione non c'è differenza tra singolo pragma e due pragma. Ma in pratica è possibile effettuare più filo comportamenti consapevoli con paralleli separati e per le direttive. Po 'di codice per esempio:

#pragma omp parallel
{ 
    double *data = (double*)malloc(...); // this data is thread private

    #pragma omp for
    for(1...100) // first parallelized cycle
    {
    }

    #pragma omp single 
    {} // make some single thread processing

    #pragma omp for // second parallelized cycle
    for(1...100)
    {
    }

    #pragma omp single 
    {} // make some single thread processing again

    free(data); // free thread private data
}

Answer 4

Anche se entrambe le versioni del caso specifico sono equivalenti, come già accennato in altre risposte, c'è ancora una piccola differenza tra di loro. La prima versione include una barriera implicita non necessaria, incontrato alla fine del "OMP per". L'altra barriera implicito si trovano alla fine della regione parallelo. Aggiungendo "nowait" a "OMP per" renderebbe i due codici equivalente, almeno dal punto di vista OpenMP. Dico questo perché un compilatore OpenMP potrebbe generare il codice leggermente diverso per i due casi.

Answer 5

Sono vedendo rigido differenti tempi di esecuzione quando prendo un ciclo for in g ++ 4.7.0 e utilizzando

std::vector<double> x;
std::vector<double> y;
std::vector<double> prod;

for (int i = 0; i < 5000000; i++)
{
   double r1 = ((double)rand() / double(RAND_MAX)) * 5;
   double r2 = ((double)rand() / double(RAND_MAX)) * 5;
   x.push_back(r1);
   y.push_back(r2);
}

int sz = x.size();

#pragma omp parallel for

for (int i = 0; i< sz; i++)
   prod[i] = x[i] * y[i];

il codice seriale (senza openmp) viene eseguito in 79 ms. il "parallelo per" codice viene eseguito in 29 ms. Se Tralascio l'for e l'uso #pragma omp parallel, il runtime spara fino a 179ms, che è più lento di codice di serie. (La macchina ha concorrenza hw di 8)

i link di codice per libgomp

Answer 6

Ci sono ovviamente un sacco di risposte, ma questo risponde molto bene (con fonte)

  

#pragma omp for solo delegati porzioni del ciclo di   diversi thread nel squadra attuale. una squadra è il gruppo di fili   l'esecuzione del programma. All'avvio del programma, la squadra è composta solo di un    singolo membro:. Il filo maestro che esegue il programma

     

Per creare un nuovo gruppo di fili, è necessario specificare il parallelo   parola chiave. Può essere specificato nel contesto circostante:

#pragma omp parallel
{
   #pragma omp for
   for(int n = 0; n < 10; ++n)
   printf(" %d", n);
}

e

  

Quali sono: parallele, e un team

     

La differenza tra parallelo,   in parallelo e per è la seguente:

     

Una squadra è il gruppo di fili   che si eseguono attualmente. All'inizio del programma, la squadra è composta da   un unico filo. Un costrutto parallelo divide il thread corrente in un   nuova squadra di fili per la durata del prossimo blocco / dichiarazione,   dopo di che la squadra si fonde di nuovo in uno solo. per divide il lavoro del   per-loop tra i fili della squadra attuale.

     

Non crea   thread, divide solo il lavoro tra i fili del momento   l'esecuzione di squadra. parallelo per è un'abbreviazione per due comandi contemporaneamente:   parallele e per. Parallelamente crea un nuovo team, e per spaccature che   squadra a gestire diverse porzioni del ciclo. Se il programma non   contiene un costrutto parallelo, non v'è mai più di un filo;   il filo principale che avvia il programma e lo esegue, come in   programmi non-threading.

https://bisqwit.iki.fi/story/howto/openmp/