openmp
OpenMP-verminderingen

Benadering van PI met clausule #pragma omp-reductie

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 dit voorbeeld voert elke thread een subset van de iteratietelling uit. Elke thread heeft zijn lokale privé-kopie van het area en aan het einde van het parallelle gebied passen ze allemaal de optelbewerking ( + ) toe om de uiteindelijke waarde voor het area te genereren.

Benadering van PI met behulp van verminderingen op basis van #pragma omp critical

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 dit voorbeeld voeren elke threads een subset van de iteratietelling uit en accumuleren ze atomair in het gedeelde variabele area , wat ervoor zorgt dat er geen verloren updates zijn.

Benadering van PI met behulp van reducties op basis van #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 dit voorbeeld voeren elke threads een subset van de iteratietelling uit en accumuleren ze atomair in het gedeelde variabele area , wat ervoor zorgt dat er geen verloren updates zijn. We kunnen de #pragma atomic hier gebruiken omdat de gegeven bewerking ( += ) atomair kan worden uitgevoerd, wat de leesbaarheid vereenvoudigt in vergelijking met het gebruik van de #pragma omp critical .

Benadering van PI met de hand vervaardigen van de #pragma omp-reductie

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;

De threads worden voortgebracht in de #pragma omp parallel . Elke thread heeft een onafhankelijke / private thread_area waarin de gedeeltelijke toevoeging wordt opgeslagen. De volgende lus wordt verdeeld over threads met #pragma omp for . In deze lus berekent elke thread zijn eigen thread_area en na deze lus aggregeert de code achtereenvolgens het gebied atomair via #pragma omp atomic .