← Volver a los ejercicios

Tres formas de paralelizar el mismo ciclo

El mismo ciclo que suma un vector de un millón de enteros, escrito con std::thread, con TBB y con OpenMP. Escriba cuánto cree que tarda la versión de hilos manuales antes de destapar los tiempos medidos y después decida qué enfoque le conviene a cada una de tres situaciones.

1. El mismo ciclo, tres veces

Sumar un vector de 1.000.000 de enteros con cuatro hilos. Las tres versiones calculan lo mismo; lo que cambia es cuánto hay que escribir y quién administra los hilos.

1#include <thread>
2#include <vector>
3using namespace std;
4
5void sumar_parcial(int ini, int fin,
6 const vector<int>& v, long& salida) {
7 for (int i = ini; i < fin; i++)
8 salida += v[i];
9}
10int main() {
11 const int SIZE = 1000000;
12 vector<int> datos(SIZE, 1);
13 long sal1 = 0, sal2 = 0, sal3 = 0, sal4 = 0;
14
15 thread t1(sumar_parcial, 0, SIZE/4, ref(datos), ref(sal1));
16 thread t2(sumar_parcial, SIZE/4, SIZE/2, ref(datos), ref(sal2));
17 thread t3(sumar_parcial, SIZE/2, 3*SIZE/4, ref(datos), ref(sal3));
18 thread t4(sumar_parcial, 3*SIZE/4, SIZE, ref(datos), ref(sal4));
19
20 t1.join(); t2.join(); t3.join(); t4.join();
21 long resultado = sal1 + sal2 + sal3 + sal4;
22 return 0;
23}
1#include <tbb/tbb.h>
2#include <vector>
3using namespace std;
4
5int main() {
6 const int SIZE = 1000000;
7 vector<int> datos(SIZE, 1);
8
9 long resultado = tbb::parallel_reduce(
10 tbb::blocked_range<int>(0, SIZE),
11 0L,
12 [&](tbb::blocked_range<int> r, long init) -> long {
13 for (int i = r.begin(); i < r.end(); i++)
14 init += datos[i];
15 return init;
16 },
17 [](long x, long y) -> long {
18 return x + y;
19 }
20 );
21 return 0;
22}
1#include <omp.h>
2#include <vector>
3using namespace std;
4
5int main() {
6 const int SIZE = 1000000;
7 vector<int> datos(SIZE, 1);
8 long resultado = 0;
9
10 #pragma omp parallel for reduction(+:resultado)
11 for (int i = 0; i < SIZE; i++)
12 resultado += datos[i];
13
14 return 0;
15}
La barra de color marca lo que cada enfoque agrega sobre el ciclo: la función parcial, los cuatro hilos con sus subrangos y la combinación de los parciales en el primero; la llamada a parallel_reduce con sus dos lambdas en el segundo; la directiva en el tercero. Las cifras de líneas son las de la tabla comparativa de la sesión. Con OpenMP el ciclo secuencial queda intacto y lo único nuevo es la línea del #pragma.

2. Antes de ver los tiempos

Un millón de enteros, cuatro hilos. La versión secuencial tarda 0,13 ms. ¿Cuánto tarda la de std::thread?

3. Los cuatro tiempos

EnfoqueTiempoContra el secuencial

4. Mil repeticiones

Ahora el ciclo se repite mil veces sobre un vector de 100.000 enteros, siempre con cuatro hilos. OpenMP abre mil regiones paralelas; la versión con std::thread crea sus cuatro hilos en cada repetición.

EstrategiaTotalPor repetición

El mismo ciclo mil veces: OpenMP 24 ms y std::thread 116 ms. ¿De dónde sale la diferencia?

5. Cuál usar

Tres situaciones de un proyecto real. Elija el enfoque que menos trabajo cuesta en cada una.