preassegnati std privato :: vector in OpenMP parallelized ciclo for C++

Question

intendo usare tamponi std::vector<size_t> buffer(100), uno per ogni filo in una parallelizzazione di un ciclo, come suggerito da questo codice:

std::vector<size_t> buffer(100); 
#pragma omp parallel for private(buffer) 
for(size_t j = 0; j < 10000; ++j) { 
    // ... code using the buffer ... 
} 

Questo il codice non funziona. Sebbene sia presente un buffer per ogni thread, questi possono avere la dimensione 0.

Come posso allocare il buffer all'inizio di ogni thread? Posso ancora usare #pragma omp parallel for? E posso farlo più elegante di questo:

std::vector<size_t> buffer; 
#pragma omp parallel for private(buffer) 
for(size_t j = 0; j < 10000; ++j) { 
    if(buffer.size() != 100) { 
     #pragma omp critical 
     buffer.resize(100); 
    } 
    // ... code using the buffer ... 
} 

Answer 1

Spalato regione OpenMP, come mostrato in this question.

Quindi dichiarare il vettore all'interno della regione esterna, ma all'esterno del ciclo stesso. Questo renderà un vettore locale per ogni thread.

#pragma omp parallel 
{ 
    std::vector<size_t> buffer(100); 

#pragma omp for 
    for(size_t j = 0; j < 10000; ++j) { 
    { 

     // ... code using the buffer ... 

    } 
} 

Answer 2

La domanda e la risposta accettata sono stati intorno per un po ', ecco alcune informazioni che forniscono ulteriori indizi openMP e quindi potrebbe essere utile ad altri utenti.

In C++, gli oggetti private e firstprivate clausola di classe maniglia in modo diverso:

Dal v3.1 OpenMP Application Program Interface:

privato: il nuovo elemento della lista viene inizializzato, o ha un valore iniziale indefinito, come se fosse stato dichiarato localmente senza inizializzatore. L'ordine in cui sono chiamati i costruttori predefiniti per variabili private diverse del tipo di classe non è specificato.

firstprivate: per le variabili di tipo di classe, un costruttore di copia viene invocato per eseguire la inizializzazione delle variabili di lista.

cioè private chiama il costruttore di default, che firstprivate chiama il costruttore di copie della classe corrispondente.

Il costruttore di default di std::vector costruisce un contenitore vuoto senza elementi, questo è il motivo per cui i buffer hanno dimensioni 0.

Per rispondere alla domanda, questo sarebbe un altra soluzione senza necessità di suddividere la regione OpenMP:

std::vector<size_t> buffer(100, 0); 
#pragma omp parallel for firstprivate(buffer) 
for (size_t j = 0; j < 10000; ++j) { 
    // use the buffer 
} 

EDIT una parola di cautela riguardo variabili private in generale: la dimensione dello stack filettatura è limitato e se non esplicitamente impostato (variabile ambiente OMP_STACKSIZE) compilatore dipendente. Se si utilizzano variabili private con un ingombro di memoria di grandi dimensioni, l'overflow dello stack può diventare un problema.