openmp
Reducciones de OpenMP
Buscar..
Observaciones
Todas las 4 versiones son válidas, pero ejemplifican diferentes aspectos de una reducción.
Por defecto, la primera construcción que usa la cláusula de reduction debe ser preferida . Esto es solo si algunos problemas se identifican explícitamente que cualquiera de las 3 alternativas puede ser explorada.
Aproximación de PI a mano la reducción de #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;
Los hilos se generan en el #pragma omp paralelo. Cada subproceso tendrá un área de subproceso independiente / privada que almacena su adición parcial. El siguiente bucle se distribuye entre subprocesos usando #pragma omp para. En este bucle, cada subproceso calcula su propia área de subproceso y, después de este bucle, el código agrega el área de forma secuencial a través de
Aproximación de PI usando reducciones basadas en # pragma atomic
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;
En este ejemplo, cada subproceso ejecuta un subconjunto del recuento de iteraciones y se acumula atómicamente en el área de la 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 crítico.
Aproximación de PI usando reducciones basadas en #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;
En este ejemplo, cada subproceso ejecuta un subconjunto del recuento de iteraciones y se acumula atómicamente en el área de la variable compartida, lo que garantiza que no haya actualizaciones perdidas.
Aproximación de PI usando la cláusula de reducción # 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;
En este ejemplo, cada subproceso ejecuta un subconjunto del recuento de iteraciones. Cada hilo tiene su copia privada local del área y al final de la región paralela todos aplican la operación de suma (+) para generar el valor final para el área.