c++ - programacion - openmp tutorial

OpenMP anidado paralelo para bucles vs paralelo interno para

Question

Si utilizo paralelos anidados para bucles como este:

#pragma omp parallel for schedule(dynamic,1)
for (int x = 0; x < x_max; ++x) {
    #pragma omp parallel for schedule(dynamic,1)
    for (int y = 0; y < y_max; ++y) { 
    //parallelize this code here
   }
//IMPORTANT: no code in here
}

es esto equivalente a:

for (int x = 0; x < x_max; ++x) {
    #pragma omp parallel for schedule(dynamic,1)
    for (int y = 0; y < y_max; ++y) { 
    //parallelize this code here
   }
//IMPORTANT: no code in here
}

¿Es el paralelo externo para hacer algo más que crear una nueva tarea?

Answer 1

NO.

El primer #pragma omp parallel creará un equipo de subprocesos paralelos y el segundo intentará crear para cada uno de los subprocesos originales otro equipo, es decir, un equipo de equipos. Sin embargo, en casi todas las implementaciones existentes, el segundo equipo tiene solo un hilo: la segunda región paralela no se usa esencialmente. Por lo tanto, su código es más parecido a

#pragma omp parallel for schedule(dynamic,1)
for (int x = 0; x < x_max; ++x) {
    // only one x per thread
    for (int y = 0; y < y_max; ++y) { 
        // code here: each thread loops all y
    }
}

Si no quieres eso, pero solo paraleliza el bucle interno, puedes hacer esto:

#pragma omp parallel
for (int x = 0; x < x_max; ++x) {
    // each thread loops over all x
#pragma omp for schedule(dynamic,1)
    for (int y = 0; y < y_max; ++y) { 
        // code here, only one y per thread
    }
}

Answer 2

Si su compilador es compatible con OpenMP 3.0, puede usar la cláusula de collapse :

#pragma omp parallel for schedule(dynamic,1) collapse(2)
for (int x = 0; x < x_max; ++x) {
    for (int y = 0; y < y_max; ++y) { 
    //parallelize this code here
    }
//IMPORTANT: no code in here
}

Si no lo hace (por ejemplo, solo se admite OpenMP 2.5), hay una solución sencilla:

#pragma omp parallel for schedule(dynamic,1)
for (int xy = 0; xy < x_max*y_max; ++xy) {
    int x = xy / y_max;
    int y = xy % y_max;
    //parallelize this code here
}

Puede habilitar el paralelismo anidado con omp_set_nested(1); y su omp parallel for anidado omp parallel for código funcionará, pero esa podría no ser la mejor idea.

Por cierto, ¿por qué la programación dinámica? ¿Se evalúa cada iteración de bucle en tiempo no constante?