openmp
Riduzioni OpenMP

Approssimazione di PI usando la clausola di riduzione #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;

In questo esempio, ogni thread esegue un sottoinsieme del conteggio dell'iterazione. Ogni thread ha la sua copia locale privata di area e alla fine della regione parallela tutti applicano l'operazione di aggiunta ( + ) in modo da generare il valore finale per l' area .

Approssimazione di PI usando riduzioni basate su #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;

In questo esempio, ogni thread eseguono un sottoinsieme del conte iterazione e si accumulano atomicamente nella variabile condivisa area , che assicura che non ci sono aggiornamenti persi.

Approssimazione di PI usando riduzioni basate su #pragma atomico

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;

In questo esempio, ogni thread eseguono un sottoinsieme del conte iterazione e si accumulano atomicamente nella variabile condivisa area , che assicura che non ci sono aggiornamenti persi. Possiamo usare l' #pragma atomic qui perché l'operazione data ( += ) può essere eseguita atomicamente, il che semplifica la leggibilità rispetto all'uso di #pragma omp critical .

Approssimazione di PI per la lavorazione a mano della riduzione di #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;

I thread sono generati nel #pragma omp parallel . Ogni thread avrà una thread_area indipendente / privata che memorizza la sua aggiunta parziale. Il seguente ciclo è distribuito tra i thread usando #pragma omp for . In questo ciclo, ogni thread calcola la propria thread_area e, dopo questo ciclo, il codice aggrega sequenzialmente l'area atomicamente tramite #pragma omp atomic .