Tareas, dependencias e ICVs

💡 En simple

Un task es un post-it con una tarea pegado en un tablero: quien lo crea no tiene que hacerlo en ese momento; cualquier hilo libre lo despega y lo hace. Con depend escribes en el post-it “no empieces hasta que terminen los que escriben x”. taskwait es “no sigo hasta que se terminen todos los post-its que pegué”.

Sirve para trabajo irregular (recorrer árboles, listas, recursión), donde un for no encaja.

task

#pragma omp task [untied] [default(shared|none)] [private(list)] [shared(list)]
                 [firstprivate(list)] [if(expr)] [depend(tipo: lista)]
    bloque

La tarea se ejecuta de inmediato o se difiere, según haya hilos libres. Patrón típico: un solo hilo crea las tareas (dentro de single) y el equipo entero las ejecuta.

U4.3 — tres tareas sin dependencias

#pragma omp parallel num_threads(2)
{
    #pragma omp single
    {
        #pragma omp task
        printf("t1 : impresion random desde el hilo : %d\n", omp_get_thread_num());
        #pragma omp task
        printf("t2 : impresion random desde el hilo : %d\n", omp_get_thread_num());
        #pragma omp task
        printf("t3 : impresion random desde el hilo : %d\n", omp_get_thread_num());
    }
}

El orden de t1, t2, t3 y el hilo que ejecuta cada una cambian en cada corrida.

Cómo leerlo: el hilo 0, dentro de single, crea tres tareas y las deja en un pool. Los demás hilos las toman cuando están libres. La flecha roja es la dependencia out(x) → in(x): T2 no puede empezar hasta que T1 termine. T3 no tiene depend, así que puede correr en cualquier momento. taskwait hace que el hilo 0 espere a sus tres tareas hijas.

depend: ordenar tareas

Tipo	Significa	Espera a tareas anteriores que tengan la misma variable en…
in	la tarea lee la variable	out o inout
out / inout	la tarea escribe (o lee y escribe)	in, out o inout

Es la misma idea de las dependencias del DAG (U1.3): lectura después de escritura, escritura después de lectura y escritura después de escritura. Dos lecturas no se ordenan entre sí.

Tareas con dependencias: task depend(in/out)

Un hilo (dentro de single) crea las tareas en orden; luego cualquier hilo libre las ejecuta. Las flechas son esperas obligatorias.

out → in: imprime 2in → out: imprime 1out, out + taskwait: imprime 2out → dos in: orden libresin depend: orden aleatorio🎲 Otra ejecución

int x = 1;
#pragma omp parallel
#pragma omp single
{
    #pragma omp task shared(x) depend(out: x)
    x = 2;
    #pragma omp task shared(x) depend(in: x)
    printf("x = %d", x);
}

⏮︎◀︎▶︎ Play▶︎⏭︎

0.5×1×2×4×

tarea 0/2

(salida vacía)

En el examen: «¿qué imprime?»

1. Ordena las tareas en el orden en que se crean (orden del código).
2. Para cada una, dibuja una flecha desde cada tarea anterior con la que choca (out–in, in–out, out–out).
3. Lo que no está unido por flechas puede ocurrir en cualquier orden ⇒ hay varias salidas posibles.

taskwait, taskgroup, taskyield

• taskwait: el hilo espera a que terminen las tareas hijas que creó hasta ese punto.
• taskgroup { … }: espera a todas las tareas creadas dentro del bloque y sus descendientes. En el ejemplo de U4.3, start_background_work() se crea fuera del grupo, así que sigue corriendo libre mientras cada paso espera solo al recorrido del árbol (compute_tree). Con taskwait participarían todas las tareas hijas.
• taskyield: la tarea actual cede el hilo para que corra otra tarea. Mejora la concurrencia cuando hay tareas largas que podrían acaparar un hilo.

Variables de control interno (ICVs)

Cada región/tarea recibe una copia de las ICVs, que controlan el comportamiento del programa:

Función	Controla
omp_set_num_threads(n)	hilos de la próxima región paralela
omp_set_dynamic(0/1)	si el runtime puede ajustar el número de hilos
omp_set_nested(0/1)	permitir regiones paralelas anidadas
omp_set_max_active_levels(n)	cuántos niveles anidados pueden estar activos

Consultas útiles: omp_get_num_threads(), omp_get_thread_num(), omp_get_max_threads(), omp_get_max_active_levels(), omp_get_wtime().

U4.3 — paralelismo anidado

omp_set_nested(1);
omp_set_max_active_levels(8);
omp_set_dynamic(0);
omp_set_num_threads(2);
#pragma omp parallel                 // nivel externo: 2 hilos
{
    omp_set_num_threads(3);
    #pragma omp parallel             // cada uno abre un equipo de 3
    {
        omp_set_num_threads(4);
        #pragma omp single
        printf("Inner: ...");        // se imprime 2 veces (una por equipo interno)
    }
    #pragma omp barrier
    #pragma omp single
    printf("Outer: ...");            // se imprime 1 vez
}

Conexión con Ejemp06

Sin omp_set_nested(1), una región paralela dentro de otra corre con un solo hilo. Eso es lo que hace que Ejemp06_reduction.cpp repita el bucle completo en cada hilo externo (ver Alcance de datos).

Grano grueso con parallel solo

No siempre hace falta for: cada hilo puede calcular qué parte del arreglo le toca a partir de su id y del número de hilos. Es la misma idea de “n/p datos por proceso” de MPI, pero en memoria compartida.

U4.3 — cada hilo elige su subdominio

#pragma omp parallel default(shared) private(iam, nt, ipoints, istart)
{
    iam = omp_get_thread_num();
    nt = omp_get_num_threads();
    ipoints = npoints / nt;              // tamaño del bloque
    istart = iam * ipoints;              // inicio del bloque
    if (iam == nt - 1)                   // el último hilo hace lo que sobra
        ipoints = npoints - istart;
    subdomain(x, istart, ipoints);
}

Ejercicio

int x = 1;
#pragma omp parallel
#pragma omp single
{
    #pragma omp task shared(x) depend(out: x)
    x = 2;
    #pragma omp task shared(x) depend(in: x)
    printf("x+1 = %d. ", x + 1);
    #pragma omp task shared(x) depend(in: x)
    printf("x+2 = %d\n", x + 2);
}

¿Cuáles son las salidas posibles? ¿Puede salir x+1 = 2?

Ver solución

Las dos tareas que imprimen dependen de la primera (in después de out), así que siempre ven x = 2. Entre ellas no hay dependencia (dos in), por lo que el orden es libre:

• x+1 = 3. x+2 = 4
• x+2 = 4 y luego x+1 = 3.

x+1 = 2 no puede salir: requeriría leer x antes de que la primera tarea la cambie.

Errores típicos

• Crear las tareas fuera de single: cada hilo del equipo las crea, y se ejecutan p veces.
• Olvidar que las variables locales del creador son, por defecto, firstprivate en la tarea: si la tarea las modifica, el cambio no se ve fuera. Usa shared y luego taskwait.
• Usar el resultado de una tarea sin taskwait (o taskgroup) antes.
• Esperar que depend ordene tareas de padres distintos: solo ordena tareas hermanas (creadas por la misma tarea).

Práctica extra

Se crean en este orden: T1 depend(out: a), T2 depend(in: a), T3 depend(out: a), T4 depend(in: b). ¿Qué órdenes son posibles?

Ver solución

• T1 → T2 (T2 lee lo que T1 escribe).
• T2 → T3 (T3 no puede escribir a antes de que T2 lo lea).
• T1 → T3 (dos escrituras de a en orden).
• T4 no comparte variables con nadie: va en cualquier lugar.

Así que T1, T2, T3 siempre en ese orden, y T4 en cualquiera de las 4 posiciones: 4 órdenes posibles (T4 T1 T2 T3, T1 T4 T2 T3, T1 T2 T4 T3, T1 T2 T3 T4), además de que T4 puede correr a la vez que cualquiera.

Autoevaluación

0/5 correctas · 0 respondidas Reiniciar

1. Una tarea con depend(in: x) espera a tareas anteriores con…

a) in sobre xb) out o inout sobre xc) cualquier variabled) nada

2. Orden de creación: in: x (printf) y luego out: x (x = 2), con x = 1 al inicio. Se imprime…

a) 1b) 2c) 1 o 2d) nada

3. taskwait espera a…

a) todos los hilosb) las tareas hijas creadas hasta ese puntoc) solo la última taread) las tareas de otros hilos

4. Sin omp_set_nested(1), un parallel dentro de otro parallel usa…

a) el doble de hilosb) 1 hilo por región internac) errord) los mismos hilos repartidos

5. ¿Por qué se suelen crear las tareas dentro de single?

a) para que no se creen T copias de cada tareab) porque task no funciona sin singlec) para ordenarlasd) para que corran en el maestro

Fuente ·U4.3 Paralelismo compartido-OMP.pdf (ICVs, parallel, task, depend, taskgroup, taskyield)