openmp
OpenMP-Reduzierungen

Annäherung von PI mit #pragma omp Reduktionsklausel

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

In diesem Beispiel führen alle Threads eine Teilmenge des Iterationszählers aus. Jeder Thread hat seine lokale private Kopie des area und am Ende des parallelen Bereichs wenden sie alle die Additionsoperation ( + ) an, um den endgültigen Wert für den area zu erzeugen.

Annäherung von PI unter Verwendung von Reduktionen basierend auf #pragma omp kritisch

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

In diesem Beispiel führen alle Threads eine Teilmenge des Iterationszählers aus und sammeln sich atomar im area der gemeinsam genutzten Variablen area , wodurch sichergestellt wird, dass keine Updates verloren gehen.

Annäherung von PI unter Verwendung von Reduktionen basierend auf #pragma atomic

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

In diesem Beispiel führen alle Threads eine Teilmenge des Iterationszählers aus und sammeln sich atomar im area der gemeinsam genutzten Variablen area , wodurch sichergestellt wird, dass keine Updates verloren gehen. Wir können hier das #pragma atomic , da die gegebene Operation ( += ) atomar ausgeführt werden kann, was die Lesbarkeit im Vergleich zur Verwendung des #pragma omp critical .

Annäherung an PI Hand-Crafting der #pragma omp-Reduktion

h = 1.0 / n;

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

  #pragma omp for
  for (i = 1; i <= n; i++)
  {
    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
}

pi = h * area;

Die Threads werden in der #pragma omp parallel . Jeder Thread verfügt über einen unabhängigen / privaten thread_area , in dem die teilweise Addition thread_area . Die folgende Schleife wird mit #pragma omp for unter den Threads #pragma omp for . In dieser Schleife berechnet jeder Thread seinen eigenen thread_area und nach dieser Schleife aggregiert der Code die Fläche nacheinander atomar durch #pragma omp atomic .