openmp
Reducciones de OpenMP

Aproximación de PI usando la cláusula de reducción # 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;

En este ejemplo, cada subproceso ejecuta un subconjunto del recuento de iteraciones. Cada hilo tiene su copia privada local del area y al final de la región paralela todos aplican la operación de suma ( + ) para generar el valor final para el area .

Aproximación de PI usando reducciones basadas en #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;

En este ejemplo, cada subproceso ejecuta un subconjunto del recuento de iteraciones y se acumula atómicamente en el area variable compartida, lo que garantiza que no haya actualizaciones perdidas.

Aproximación de PI usando reducciones basadas en # 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;

En este ejemplo, cada subproceso ejecuta un subconjunto del recuento de iteraciones y se acumula atómicamente en el area variable compartida, lo que garantiza que no haya actualizaciones perdidas. Podemos usar el #pragma atomic aquí porque la operación dada ( += ) se puede hacer atómicamente, lo que simplifica la legibilidad en comparación con el uso del #pragma omp critical .

Aproximación de PI a mano la reducción de #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;

Los hilos se generan en el #pragma omp parallel . Cada hilo tendrá una organización independiente / privada thread_area que almacena su adición parcial. El siguiente bucle se distribuye entre subprocesos usando #pragma omp for . En este bucle, cada subproceso calcula su propia área de thread_area y, después de este bucle, el código agrega el área de forma secuencial a través de #pragma omp atomic .