openmp
OpenMP-minskningar

Tillnärmning av PI med användning av #pragma omp-reduktionsklausul

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;

I det här exemplet kör varje trådar en delmängd av iterationsräkningen. Varje tråd har sin lokala privata kopia av area och i slutet av det parallella området tillämpar de alla tilläggsoperationen ( + ) för att generera det slutliga värdet för area .

Tillnärmning av PI med hjälp av reduktioner baserade på #pragma omp-kritisk

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;

I det här exemplet var ämnen utför en delmängd av iteration räkningen och de ackumuleras atomärt i den delade variabla area , vilket säkerställer att det inte finns några förlorade uppdateringar.

Tillnärmning av PI med användning av reduktioner baserade på #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;

I det här exemplet var ämnen utför en delmängd av iteration räkningen och de ackumuleras atomärt i den delade variabla area , vilket säkerställer att det inte finns några förlorade uppdateringar. Vi kan använda #pragma atomic här eftersom den givna operationen ( += ) kan utföras atomiskt, vilket förenklar läsbarheten jämfört med användningen av #pragma omp critical .

Tillnärmning av PI-handgjorda #pragma-omp-reduktionen

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;

Trådarna är spawned i #pragma omp parallel . Varje tråd har en oberoende / privat thread_area som lagrar dess delvisa tillägg. Följande slinga distribueras mellan trådar med #pragma omp for . I denna loop beräknar varje tråd sin egen thread_area och efter denna slinga aggregerar koden sekventiellt området atomiskt genom #pragma omp atomic .