← Volver a los ejercicios

Doce hilos no dan doce veces la velocidad

Prediga con cuántos hilos la integral de pi llega a su mejor tiempo y destape después la aceleración y la eficiencia de las doce corridas. Con esas dos columnas estime qué fracción del programa quedó secuencial y compare el codo medido contra el techo de Amdahl.

1. El programa y el barrido

Integral de 4/(1+x²) por rectángulos. El pragma reparte el ciclo de mil millones de iteraciones y reduction junta las sumas parciales de cada hilo:

1const long N = 1000000000L; // mil millones de rectangulos
2double integrar() {
3 double paso = 1.0 / N;
4 double suma = 0.0;
5 #pragma omp parallel for reduction(+ : suma)
6 for (long i = 0; i < N; i++) {
7 double x = (i + 0.5) * paso;
8 suma += 4.0 / (1.0 + x * x);
9 }
10 return suma * paso;
11}

Cada corrida repite la integral tres veces y reporta la más rápida:

12int main() {
13 double mejor = 1e30, pi = 0.0;
14 for (int r = 0; r < 3; r++) {
15 auto ini = chrono::high_resolution_clock::now();
16 pi = integrar();
17 auto fin = chrono::high_resolution_clock::now();
18 double ms = chrono::duration<double, milli>(fin - ini).count();
19 if (ms < mejor) mejor = ms;
20 }
21 printf("%2d hilos pi = %.10f %8.1f ms\n",
22 omp_get_max_threads(), pi, mejor);
23 return 0;
24}

El barrido llama al mismo binario doce veces, una por cada número de hilos:

1g++ -std=c++17 -fopenmp -O2 escalado.cpp -o escalado
2export OMP_DYNAMIC=false
3for t in $(seq 1 12); do OMP_NUM_THREADS=$t ./escalado; done
El barrido corrió en un AMD Ryzen 5 3600 de 6 núcleos y 12 hilos de hardware, con g++ -O2. De cada número de hilos queda el mínimo de tres repeticiones, y OMP_DYNAMIC=false deja fijo el número de hilos que pide OMP_NUM_THREADS.

2. Antes de ver la tabla

El mismo binario corrió con 1, 2, 3 y así hasta 12 hilos sobre seis núcleos físicos. ¿Con cuántos hilos se alcanza el mejor tiempo?

3. Aceleración y eficiencia

S(p) = T(1)/T(p) dice cuántas veces más rápido corre con p hilos; E(p) = S(p)/p, cuánto de cada hilo se aprovecha.

HilosTiempo (ms)S(p)E(p)
nproc cuenta hilos lógicos: 6 núcleos por 2. OpenMP toma los 12 por defecto, así que dos hilos se turnan las mismas unidades de ejecución. La columna E(p) es donde eso se mide.

4. El codo

Karp y Flatt despejan la fracción secuencial a partir de la aceleración medida: f = (1/S(p) - 1/p) / (1 - 1/p).

p246812

Con doce hilos la aceleración es 4,89 y con seis es 4,96. ¿Qué dice eso?

5. El techo de Amdahl

Si una fracción f del programa corre secuencial, S(p) = 1 / (f + (1 - f)/p) y el techo con cualquier número de hilos es 1/f. Mueva las dos perillas:

10 %
12

f secuencial4 hilos12 hilos64 hilosTecho 1/f
Con un 10 % secuencial, pasar de 12 a 64 hilos gana apenas un 54 % y el techo está en 10. La fila del 25 % enseña el otro extremo: el techo es 4 y 64 hilos apenas alcanzan 3,8.