Wie kann eine Array-Reduktion in OpenMP erreicht werden, wenn es nicht direkt unterstützt wird?

Reduzierung von Arrays in OpenMP

OpenMP bietet parallele Ausführungsfunktionen für eine Vielzahl von Anwendungen. Allerdings stellt sich häufig die Frage bezüglich der Array-Reduktion, die von OpenMP nicht direkt unterstützt wird.

Alternative Lösung

Eine native Array-Reduktion ist zwar nicht verfügbar, es gibt jedoch alternative Methoden um eine ähnliche Funktionalität in C/C zu erreichen:

Methode 1: Private Array Reduction mit Critical Abschnitt

Bei diesem Ansatz arbeitet jeder Thread mit einer privaten Kopie des Arrays und akkumuliert seine Beiträge. Wenn alle Threads abgeschlossen sind, wird ein kritischer Abschnitt verwendet, um die einzelnen Array-Elemente in das ursprüngliche Array zusammenzuführen.

int S [10] = {0};
#pragma omp parallel
{
    int S_private[10] = {0};
    #pragma omp for
    for (int n=0 ; n<10 ; ++n ) {
        for (int m=0; m<=n; ++m){
            S_private[n] += A[m];
        }
    }
    #pragma omp critical
    {
        for(int n=0; n<10; ++n) {
            S[n] += S_private[n];
        }
    }
}

Methode 2: Thread-lokale Array-Reduktion

Diese Methode eliminiert den kritischen Abschnitt, indem ein Zwischenarray mit den Abmessungen 10*nthreads erstellt wird. Threads füllen dieses Array parallel und führen es dann mit dem ursprünglichen Array zusammen.

int S [10] = {0};
int *S_private;
#pragma omp parallel
{
    const int nthreads = omp_get_num_threads();
    const int ithread = omp_get_thread_num();

    #pragma omp single 
    {
        S_private = new int[10*nthreads];
        for(int i=0; i<(10*nthreads); i++) S_private[i] = 0;
    }
    #pragma omp for
    for (int n=0 ; n<10 ; ++n )
    {
        for (int m=0; m<=n; ++m){
            S_private[ithread*10+n] += A[m];
        }
    }
    #pragma omp for
    for(int i=0; i<10; i++) {
        for(int t=0; t<nthreads; t++) {
            S[i] += S_private[10*t + i];
        }
    }
}
delete[] S_private;

Diese Ansätze überwinden den Mangel an nativer Array-Reduzierung in OpenMP und ermöglichen eine effiziente parallele Akkumulation von Array-Elementen.

Das obige ist der detaillierte Inhalt vonWie kann eine Array-Reduktion in OpenMP erreicht werden, wenn es nicht direkt unterstützt wird?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!