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:
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.
Hilos
Tiempo (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).
p
2
4
6
8
12
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 secuencial
4 hilos
12 hilos
64 hilos
Techo 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.