Muss der Schleifenindex als private Variable in OpenMP festgelegt werden?

Question

Ich lese diesen OpenMP tutorial und komme über folgendes Programm:

#include <omp.h> 
#include <stdio.h> 
#include <stdlib.h> 
#define N  100 

int main (int argc, char *argv[]) { 

int nthreads, tid, i; 
float a[N], b[N], c[N]; 

/* Some initializations */ 
for (i=0; i < N; i++) 
    a[i] = b[i] = i; 


#pragma omp parallel shared(a,b,c,nthreads) private(i,tid) 
    { 
    tid = omp_get_thread_num(); 
    if (tid == 0) 
    { 
    nthreads = omp_get_num_threads(); 
    printf("Number of threads = %d\n", nthreads); 
    } 

    printf("Thread %d starting...\n",tid); 

    #pragma omp for 
    for (i=0; i<N; i++) 
    { 
    c[i] = a[i] + b[i]; 
    printf("Thread %d: c[%d]= %f\n",tid,i,c[i]); 
    } 

    } /* end of parallel section */ 

} 

Ich bin ein wenig verwirrt, ob der Schleifenindex i sein muss, ein private Variable oder nicht. Da aus dem gleichen Tutorial:

Alle Themen können alle Variablen ändern und Zugriff (mit Ausnahme des Schleifenindex)

So scheint es, die Fäden nicht i kontrollieren können, ist es richtig? BTW, ich versuche, i von private Variable zu entfernen, und das Ergebnis scheint OK.

Answer 1

Nein, es muss nicht angegeben werden, dass eine Schleifenindexvariable private ist. OpenMP erzwingt das, und irgendwo auf seinen vielen Seiten gibt der Standard so viel an.

Des Weiteren verbieten die Anforderungen des OpenMP-Standards jegliche Anpassungen der Schleifenindexvariablen innerhalb der Schleife. Tatsächlich erzwingt OpenMP in C (und C++) Programmen eine der in Fortran eingebauten Constraints. Dies ermöglicht es der Laufzeit, mehrere Iterationen über mehrere Threads hinweg korrekt zu planen, wenn die Schleife zum ersten Mal auftritt, ohne dass befürchtet wird, dass die Verteilung während der Ausführung ungültig wird.

Denken Sie daran, dass bei der Schleifeninitialisierung Threads bei i zugewiesen werden, die die einzelnen Schleifeniterationen gemäß dem angegebenen Zeitplan verteilen (entweder vom Programmierer oder durch einen implementierungsdefinierten Standard). Würden Threads einen 'lokalen' Wert für i aktualisieren, würde das zu einem verrückten Code

führen