← Volver a los ejercicios

Una reducción se delata en el número; la otra, solo en el reloj

Tres escrituras del mismo producto punto: una reparte el ciclo entre los hilos y dos lo calculan mal sin que el compilador lo impida. Prediga qué imprime la que olvidó el for, destape los números y los tiempos de las tres, y decida al final qué se mira primero cuando una reducción parece rápida.

1. Las tres escrituras

La función suma los productos de dos vectores de SIZE enteros:

1long producto() {
2 long suma = 0L;
3 #pragma omp parallel for reduction(+ : suma)
4 for (int i = 0; i < SIZE; i++)
5 suma += (long) u[i] * v[i];
6 return suma;
7}

La directiva del tercer renglón es lo único que cambia entre las tres. A es la que acaba de ver:

A#pragma omp parallel for reduction(+ : suma)
B#pragma omp parallel reduction(+ : suma)
C#pragma parallel reduce(suma : +)
Los dos vectores tienen 100.000.000 de enteros llenos de 10, así que la suma de productos vale 10.000.000.000. Las tres corridas se hicieron con cuatro hilos en un AMD Ryzen 5 3600 de 6 núcleos y 12 hilos de hardware, compilando con g++ -std=c++17 -fopenmp -O2.

2. Antes de correr

La escritura B dice parallel sin for, con cuatro hilos y un resultado correcto de 10.000.000.000. ¿Qué número imprime?

3. Qué delata a cada una

EscrituraResultadoTiempoQué lo delata

De las tres, solo C deja rastro en la compilación, y únicamente si se pide -Wall:

$ g++ -std=c++17 -fopenmp -O2 -Wall producto.cpp -o producto
producto.cpp:27: warning: ignoring '#pragma parallel reduce'
[-Wunknown-pragmas]
El compilador no conoce #pragma parallel reduce, la ignora y sigue. El ciclo queda sin paralelizar y el programa imprime la suma correcta, calculada en un solo hilo.

4. El mismo cálculo, dos recorridos

La misma reducción sobre una matriz de 10.000 × 10.000 enteros, con los dos ciclos en un orden y en el otro:

1void reduce(int** arr, int n, long &sum) {
2 sum = 0;
3 #pragma omp parallel for reduction(+:sum)
4 for (int i = 0; i < n; i++) // por filas
5 for (int j = 0; j < n; j++)
6 sum += arr[i][j];
7}
3 #pragma omp parallel for reduction(+:sum)
4 for (int j = 0; j < n; j++) // por columnas
5 for (int i = 0; i < n; i++)
6 sum += arr[i][j];
VersiónTiempoGanancia

La versión por columnas tarda 140,24 ms y la de filas 47,72 ms, con el mismo número de hilos. ¿Por qué?

5. Cómo se revisa una reducción

Antes de creerle a los 31 ms, ¿qué se mira primero?

La salida de una reducción paralela se lee en tres renglones: el número, el tiempo y lo que dijo el compilador. Con los tres a la vista, un programa que quedó en un hilo no pasa por paralelo.