openmp
Réductions OpenMP

Remarques

Approximation de la fabrication artisanale de PI la réduction #pragma omp

int i;
int n = 1000000;
double area = 0;
double h = 1.0 / n;

#pragma omp parallel shared(n, h)
{
  double thread_area = 0;                      // Private / local variable

  #pragma omp for
  for (i = 1; i <= n; i++)
  {
    double x = h * (i - 0.5);
    thread_area += (4.0 / (1.0 + x*x));
  }

  #pragma omp atomic                       // Applies the reduction manually
  area += thread_area;                     // All threads aggregate into area
}
double pi = h * area;

Les threads sont générés dans le parallèle #pragma omp. Chaque thread aura un thread_area indépendant / privé qui stockera son ajout partiel. La boucle suivante est distribuée entre les threads utilisant #pragma omp pour. Dans cette boucle, chaque thread calcule ses propres thread_area et après cette boucle, le code agrège séquentiellement la zone de manière atomique à travers

Approximation de PI en utilisant des réductions basées sur #pragma atomic

double area;
double h = 1.0 / n;
#pragma omp parallel for shared(n, h, area) 
for (i = 1; i <= n; i++)
{
  double x = h * (i - 0.5);
  #pragma atomic
  area += (4.0 / (1.0 + x*x));
}
pi = h * area;

Dans cet exemple, chaque thread exécute un sous-ensemble du nombre d'itérations et il s'accumule de manière atomique dans la zone de la variable partagée, ce qui garantit qu'il n'y a pas de mises à jour perdues. Nous pouvons utiliser l'atome #pragma ici car l'opération donnée (+ =) peut être effectuée de manière atomique, ce qui simplifie la lisibilité par rapport à l'utilisation du #pragma omp critical.

Approximation de PI en utilisant des réductions basées sur #pragma omp critical

double area;
double h = 1.0 / n;
#pragma omp parallel for shared(n, h, area) 
for (i = 1; i <= n; i++)
{
  double x = h * (i - 0.5);
  #pragma omp critical
  {
    area += (4.0 / (1.0 + x*x));
  }
}
double pi = h * area;

Dans cet exemple, chaque thread exécute un sous-ensemble du nombre d'itérations et il s'accumule de manière atomique dans la zone de la variable partagée, ce qui garantit qu'il n'y a pas de mises à jour perdues.

Approximation de PI en utilisant la clause de réduction #pragma omp

int i;
int n = 1000000;
double area = 0;
double h = 1.0 / n;
#pragma omp parallel for shared(n, h) reduction(+:area) 
for (i = 1; i <= n; i++)
{
  double x = h * (i - 0.5);
  area += (4.0 / (1.0 + x*x));
}
pi = h * area;

Dans cet exemple, chaque thread exécute un sous-ensemble du nombre d'itérations. Chaque thread a sa copie privée locale de la zone et à la fin de la région parallèle, ils appliquent tous l'opération d'ajout (+) afin de générer la valeur finale pour la zone.