openmp
OpenMP-minskningar

Anmärkningar

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

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;

Trådarna är spawned i #pragma-omp-parallellen. 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 för. I den här slingan beräknar varje tråd sin egen tråd_area och efter denna slinga aggregerar koden sekventiellt området atomiskt genom

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

I det här exemplet kör varje trådar en delmängd av iterationsräkningen och de ackumuleras atomiskt i det delade variabelområdet, vilket säkerställer att det inte finns några förlorade uppdateringar. Vi kan använda #pragma-atomen här eftersom den givna operationen (+ =) kan utföras atomiskt, vilket förenklar läsbarheten jämfört med användningen av #pragma-omp-kritiken.

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

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;

I det här exemplet kör varje trådar en delmängd av iterationsräkningen och de ackumuleras atomiskt i det delade variabelområdet, vilket säkerställer att det inte finns några förlorade uppdateringar.

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

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;

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 området och i slutet av det parallella området tillämpar de alla tilläggsoperationen (+) för att generera det slutliga värdet för området.