openmp
Riduzioni OpenMP

Osservazioni

Approssimazione di PI per la lavorazione a mano della riduzione di #pragma omp

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;

I thread sono generati nel parallelo di #pragma omp. 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 in modo atomico attraverso

Approssimazione di PI usando riduzioni basate su #pragma atomico

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;

In questo esempio, ogni thread esegue un sottoinsieme del conteggio dell'iterazione e si accumula atomicamente nell'area della variabile condivisa, il che garantisce che non vi siano aggiornamenti persi. Possiamo usare l'atomico #pragma qui perché l'operazione data (+ =) può essere eseguita atomicamente, il che semplifica la leggibilità rispetto all'uso di #pragma omp critical.

Approssimazione di PI usando riduzioni basate su #pragma omp critical

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;

In questo esempio, ogni thread esegue un sottoinsieme del conteggio dell'iterazione e si accumula atomicamente nell'area della variabile condivisa, il che garantisce che non vi siano aggiornamenti persi.

Approssimazione di PI usando la clausola di riduzione #pragma omp

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;

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.