← Volver a los ejercicios

Depurar un programa de OpenMP

Una sesión de gdb sobre la integral de pi y un reporte de ThreadSanitizer sobre una suma sin reduction. Cada pregunta pide una predicción antes de mostrar la respuesta.

1. Cuatro hilos detenidos en el ciclo

El programa calcula pi con mil millones de iteraciones bajo #pragma omp parallel for reduction(+ : suma), con cuatro hilos y compilado con -g -O0. Con el programa detenido dentro de la región:

(gdb)info threads
Id Target Id Frame
* 1 Thread ... (LWP 9828) "escalado" _Z8integrarv._omp_fn.0 () at escalado.cpp:14
2 Thread ... (LWP 9831) "escalado" _Z8integrarv._omp_fn.0 () at escalado.cpp:14
3 Thread ... (LWP 9832) "escalado" _Z8integrarv._omp_fn.0 () at escalado.cpp:14
4 Thread ... (LWP 9833) "escalado" _Z8integrarv._omp_fn.0 () at escalado.cpp:14
(gdb)thread 3
(gdb)print i
$1 = 500000000
(gdb)print suma
$2 = 0

Las iteraciones se reparten en cuatro bloques contiguos y el hilo 3 está en la primera iteración del suyo. Si los otros tres estuvieran detenidos en el mismo punto de su bloque, ¿qué valor de i mostraría print i en cada uno?

Valor de i en el hilo 1.
Valor de i en el hilo 2.
Valor de i en el hilo 4.

2. Por qué suma vale 0

Si el ciclo acumula, ¿por qué print suma responde 0 dentro de la región, y cuándo deja de valer 0?

3. Por qué no aparece integrar

El marco dice _Z8integrarv._omp_fn.0, no integrar. ¿Por qué?

4. Lo mismo con -O2

Se recompila con -g -O2 y se repite la sesión. ¿Qué responde el depurador?

5. El reporte de ThreadSanitizer

La suma sin reduction, compilada con -fsanitize=thread. La línea 7 es el #pragma omp parallel for y la 9 es suma += i.

WARNING: ThreadSanitizer: data race (pid=22434)
Write of size 8 at 0x7ffea2fdd5a0 by thread T2:
#0 main._omp_fn.0 carrera.cpp:9
Previous read of size 8 at 0x7ffea2fdd5a0 by main thread:
#0 main._omp_fn.0 carrera.cpp:7
SUMMARY: ThreadSanitizer: data race carrera.cpp:9 in main._omp_fn.0

a) ¿Qué dos operaciones están en conflicto?

b) ¿Qué cláusula arregla la carrera?

ThreadSanitizer instrumenta cada acceso a memoria y avisa cuando dos hilos tocan la misma dirección, uno de ellos para escribir, sin sincronización. El programa corre entre 5 y 15 veces más lento, y por eso se usa en pruebas y no en las mediciones.