Comment obtenir une réduction de tableau dans OpenMP lorsqu'il n'est pas directement pris en charge ?

Réduction sur les tableaux dans OpenMP

OpenMP offre des capacités d'exécution parallèle pour une vaste gamme d'applications. Cependant, une question courante se pose concernant la réduction de tableau, qui n'est pas directement prise en charge par OpenMP.

Solution alternative

Bien que la réduction de tableau native ne soit pas disponible, il existe des méthodes alternatives pour obtenir une fonctionnalité similaire en C/C :

Méthode 1 : réduction des tableaux privés avec critique Section

Dans cette approche, chaque thread opère sur une copie privée du tableau, accumulant ses contributions. Lorsque tous les threads sont terminés, une section critique est utilisée pour fusionner les éléments individuels du tableau dans le tableau d'origine.

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];
        }
    }
}

Méthode 2 : réduction du tableau local par thread

Cette méthode élimine la section critique en créant un tableau intermédiaire de dimensions 10*nthreads. Les threads remplissent ce tableau en parallèle, puis le fusionnent dans le tableau d'origine.

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;

Ces approches pallient au manque de réduction native du tableau dans OpenMP, permettant une accumulation efficace d'éléments du tableau en parallèle.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!