openmp
Redukcje OpenMP

Przybliżenie PI przy użyciu klauzuli redukcji #pragma omp

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;

W tym przykładzie każdy wątek wykonuje podzbiór liczby iteracji. Każdy wątek ma swoją lokalną prywatną kopię area a na końcu regionu równoległego wszystkie stosują operację dodawania ( + ), aby wygenerować końcową wartość dla area .

Przybliżenie PI przy użyciu redukcji opartych na #pragma omp krytycznym

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;

W tym przykładzie każdy wątek wykonuje podzbiór liczby iteracji i kumuluje się atomowo we wspólnym area zmiennych, co zapewnia, że nie ma utraconych aktualizacji.

Przybliżenie PI przy użyciu redukcji opartych na #pragma atomowej

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;

W tym przykładzie każdy wątek wykonuje podzbiór liczby iteracji i kumuluje się atomowo we wspólnym area zmiennych, co zapewnia, że nie ma utraconych aktualizacji. Możemy tutaj użyć #pragma atomic , ponieważ daną operację ( += ) można wykonać atomowo, co upraszcza czytelność w porównaniu z użyciem #pragma omp critical .

Przybliżenie ręcznego wytwarzania PI przez redukcję #pragma omp

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;

Wątki są spawnowane w #pragma omp parallel . Każdy wątek będzie miał niezależny / prywatny thread_area który przechowuje jego częściowe dodanie. Następująca pętla jest rozdzielana między wątki za pomocą #pragma omp for . W tej pętli każdy wątek oblicza swój własny thread_area a po tej pętli kod sekwencyjnie agreguje obszar atomowo przez #pragma omp atomic .