Reduções do OpenMP

Aproximação de PI usando a cláusula de redução #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;

Neste exemplo, cada thread executa um subconjunto da contagem de iteração. Cada thread tem sua cópia privada local de area e no final da região paralela todas elas aplicam a operação de adição (+) para gerar o valor final para area.

Aproximação de PI usando reduções baseadas em #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;

Neste exemplo, cada thread executa um subconjunto da contagem de iteração e eles se acumulam atomicamente na variável compartilhada area, o que garante que não haja atualizações perdidas.

Aproximação de PI usando reduções baseadas em #pragma atômico #

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;

Neste exemplo, cada thread executa um subconjunto da contagem de iteração e eles se acumulam atomicamente na variável compartilhada area, o que garante que não haja atualizações perdidas. Podemos usar o #pragma atomic aqui porque a operação dada (+=) pode ser feita atomicamente, o que simplifica a legibilidade em comparação com o uso do #pragma omp critical.

Aproximação de PI criando manualmente a redução #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;

As threads são geradas no #pragma omp parallel. Cada thread terá uma thread_area independente/privada que armazena sua adição parcial. O loop a seguir é distribuído entre as threads usando #pragma omp for. Neste loop, cada thread calcula sua própria thread_area e após este loop, o código agrega sequencialmente a área atomicamente através de #pragma omp atomic.