Arquitecturas Paralelas IF - EHU Arquitecturas Paralelas 9. Herramientas para la programación de...

Arquitecturas Paralelas IF - EHU

Arquitecturas Paralelas

9. Herramientas para la programación de aplicaciones paralelas: OpenMP y MPI (introducción).

Computadores de alta velocidad (la lista top500).

Arquitecturas ParalelasIF - EHU

29

Como sabemos, los sistemas paralelos MIMD presentan dos arquitecturas diferenciadas: memoria compartida y memoria distribuida.

El modelo de memoria utilizado hace que la programación de aplicaciones paralelas para cada caso sea esencialmente diferente.

Programación aplicaciones paralelas


39

Para los sistemas de memoria distribuida (MPP), el “estándar” de programación, mediante paso de mensajes, es MPI.

Para los sistemas de memoria compartida tipo SMP, la herramienta más utilizada es OpenMP.

Otras opciones: UPC (Unified Parallel C)shrmem (Cray)Tarjetas gráficas: CUDA / OpenCL



49

Earth Simulator



59

OpenMPuna pequeña introducción


OpenMP 69

OpenMP es el estándar actual para programar aplicaciones paralelas en sistemas de memoria compartida.

Introducción

No se trata de un nuevo lenguaje de programación, sino de un API (application programming interface) formado por:

directivas para el compilador (C) #pragma omp <directiva>

unas pocas funciones de biblioteca algunas variables de entorno


OpenMP 79

El modelo de programación paralela que aplica OpenMP es Fork - Join.

En un determinado momento, el thread master genera P threads que se ejecutan en paralelo.

thread master

FORK

JOIN

región paralela

thread master

Introducción


OpenMP 89

Todos los threads ejecutan la misma copia del código (SPMD). A cada thread se le asigna un identificador (tid).

Para diferenciar las tareas ejecutadas por cada thread:

if (tid == 0) then ... else ...

constructores específicos de reparto de tareas (work sharing).

Introducción


OpenMP 99

En resumen, partiendo de un programa serie, para obtener un programa paralelo OpenMP hay que añadir:

directivas que especifican una región paralela (código replicado), reparto de tareas (específicas para cada thread), o sincronización entre threads.

funciones de biblioteca (include <omp.h>): para gestionar o sincronizar los threads..

Introducción


OpenMP 109

main () {

for (i=0; i<1000; i++)

{ A[i] = A[i] + 1;

B = B + A[i];

}

printf(“ B = %d \n”, B);

}

#pragma omp parallel private(tid)

{

}

tid = omp_get_thread_num();

printf (“ thread %d en marcha \n”, tid);

#pragma omp for schedule(static) reduction(+:B)

if (tid==0)

Ejemplo


OpenMP 119

0 Procesos paralelos (threads).

1 REGIONES PARALELAS. Ámbito de las variables.

2 REPARTO DE TAREAS.

Datos: bucles for. Reparto de iteraciones.Funciones: sections / single / ...

3 SINCRONIZACIÓN.

Secciones críticas, cerrojos, barreras.

Conceptos básicos


OpenMP 129

0 Número de threads

estático, una variable de entorno:: > export OMP_NUM_THREADS = 10

dinámico, mediante una función:omp_set_num_threads (10);

0 ¿Quién soy / cuántos somos?

tid = omp_get_thread_num();nth = omp_get_num_threads();

Conceptos básicos


OpenMP 139

1 REGIÓN PARALELA (parallel regions)

# pragma omp parallel [VAR,...]

{ código }

Una región paralela es un trozo de código que se va a repetir y ejecutar en paralelo en todos los threads.

Las variables de una región paralela pueden ser compartidas (shared) o privadas (private).

Regiones paralelas


OpenMP 149

> Un ejemplo sencillo:

...

#define N 12

int i, tid, nth, A[N];

main ( ) {

for (i=0; i<N; i++) A[i]=0;

#pragma omp parallel

{ nth = omp_get_num_threads ();

tid = omp_get_thread_num ();

printf ("Thread %d de %d en marcha \n", tid, nth);

A[tid] = 10 + tid;

printf (" El thread %d ha terminado \n", tid);

}

for (i=0; i<N; i++) printf (“A(%d) = %d \n”, i, A[i]);}

private(tid,nth) shared(A)

barrera

Regiones paralelas


OpenMP 159

2 REPARTO DE TAREAS: bucles

Los bucles son uno de los puntos de los que extraer paralelismo de manera “sencilla” (paralelismo de datos (domain decomposition) de grano fino). Obviamente, la simple replicación de código no es suficiente. Por ejemplo,

#pragma omp parallel shared(A) private(i){ for (i=0; i<100; i++) A[i] = A[i] + 1;}

?

Reparto de tareas: bucles


OpenMP 169

Tendríamos que hacer algo así:

#pragma omp parallel shared(A)

private(tid,nth, ini,fin,i)

{ tid = omp_get_thread_num();nth = omp_get_num_threads();

ini = tid * 100 / nth;fin = (tid+1) * 100 / nth;

for (i=ini; i<fin; i++) A[i] = A[i] + 1;

}

!

El reparto de bucles se realiza automáticamente con la directiva pragma omp for.



OpenMP 179

#pragma omp parallel [...]

{ …

#pragma omp for [clausulas]

for (i=0; i<100; i++) A[i] = A[i] + 1;…

}

ámbito variablesreparto iteracionessincronización

0..24

25..49

50..74

75..99

barrera



OpenMP 189

for (i=0; i<N; i++) for (j=0; j<M; j++) { X = B[i][j] * B[i][j]; A[i][j] = A[i][j] + X; C[i][j] = X * 2 + 1; }

Se ejecutará en paralelo el bucle externo, y los threads ejecutarán el bucle interno. Paralelismo de grano “medio”.

Las variables i, j y X se declaran como privadas.

#pragma omp parallel for private (i,j,X)




OpenMP 199


Los threads ejecutarán en paralelo el bucle interno (el externo se ejecuta en serie). Paralelismo de grano fino.

Las variables j y X se declaran como privadas.

for (i=0; i<N; i++)#pragma omp parallel for private (j,X) for (j=0; j<M; j++) { X = B[i][j] * B[i][j]; A[i][j] = A[i][j] + X; C[i][j] = X * 2 + 1; }



OpenMP 209

¿Cómo se reparten las iteraciones de un bucle entre los threads?

Puesto que el pragma for termina con una barrera, si la carga de los threads está mal equilibrada tendremos una pérdida (notable) de eficiencia.

La cláusula schedule permite definir diferentes estrategias de reparto, tanto estáticas como dinámicas.

Reparto de las iteraciones


OpenMP 219

> Ejemplo

#pragma omp parallel for

shared(A) private(i)

schedule(static,2)

for (i=0; i<32; i++)

A[i] = A[i] + 1;

Recuerda: estático menos coste / mejor localidad datos dinámico más coste / carga más equilibrada

pid iteraciones

0: 0,1,8,9,16,17,24,25 1:

2,3,10,11,18,19,26,27

2:4,5,12,13,20,21,28,29

3:6,7,14,15,22,23,30,31

Reparto de las iteraciones


OpenMP 229

#pragma omp parallel [clausulas]{ #pragma omp sections [clausulas] { #pragma omp section

fun1(); #pragma omp section

fun2(); #pragma omp section

fun3(); }}

2 REPARTO DE TAREAS: funciones

También puede usarse paralelismo de función (function decomposition), mediante la directiva sections.

Rep.de tareas: funciones

fun1

fun2

fun3

pragma omp sections


OpenMP 239

2 REPARTO DE TAREAS: funciones

Dentro de una región paralela, la directiva single asigna una tarea a un único thread.Sólo la ejecutará un thread, pero no sabemos cúal.

Rep.de tareas: funciones


OpenMP 249

3 SINCRONIZACIÓN

Cuando no pueden eliminarse las dependencias de datos entre los threads, entonces es necesario sincronizar su ejecución.

OpenMP proporciona los mecanismos de sincronización más habituales: exclusión mutua y sincronización por eventos.

Sincronización de threads


OpenMP 259

a. Secciones críticas: pragma omp critical

Por ejemplo, calcular el máximo y el mínimo de los elementos de un vector.

#pragma omp parallel for for (i=0; i<N; i++) { A[i] = fun(i);

if (A[i]>MAX) #pragma omp critical(SMAX) { if (A[i]>MAX) MAX = A[i]; }

if (A[i]<MIN) #pragma omp critical(SMIN) { if (A[i]<MIN) MIN = A[i]; } }



OpenMP 269

a. Secciones críticas: pragma omp atomic

Una sección crítica para una operación simple de tipo RMW. Por ejemplo,

#pragma omp parallel ...{ ... #pragma omp atomic X = X + 1; ...}



OpenMP 279

b. Cerrojos

- omp_set_lock (&C)

espera a que el cerrojo C esté abierto; en ese momento, cierra el cerrojo en modo atómico.

- omp_unset_lock (&C)abre el cerrojo C.

- omp_test_lock (&C)testea el valor del cerrojo C; devuelve

T/F.



OpenMP 289

> Ejemplo #pragma omp parallel private(nire_it) { omp_set_lock(&C1); mi_it = i; i = i + 1; omp_unset_lock(&C1);

while (mi_it<N) { A[mi_it] = A[mi_it] + 1;

omp_set_lock(&C1); mi_it = i; i = i + 1; omp_unset_lock(&C1); } }



OpenMP 299

#pragma omp parallel private(tid) { tid = omp_get_thread_num(); A[tid] = fun(tid);

#pragma omp for for (i=0; i<N; i++) B[i] = fun(A,i);

#pragma omp for for (i=0; i<N; i++) C[i] = fun(A,B,i);

D[tid] = fun(tid); }

c. Barreras: pragma omp barrier

#pragma omp barrier

nowait



OpenMP 309

Variables de entorno y funciones (núm. de hilos, identificadores...)

Directiva para definir regiones paralelas#pragma omp parallel [var…]

Directivas de reparto de tareas#pragma omp for [var,sched…]#pragma omp sections [var]

Directivas y funciones de sincronización#pragma omp critical [c] / atomic#pragma omp barriercerrojos (set_lock, unset_lock,

test_lock)

Resumen


OpenMP 319

TEXTOS

• R. Chandra et al.: Parallel Programming in OpenMP Morgan Kaufmann, 2001.

WEB

• www.openmp.org (especificación 3.0, software…)

COMPILADORES

• de pago • libres: p. e., el compilador de C/C++ de Intel

Más información

Arkitektura ParaleloakIF - EHU

329

MPIuna pequeña introducción


MPI 339

Si para los sistemas SMP la opción es OpenMP, el “estándar” actual de programación de los sistemas de memoria distribuida, mediante paso de mensajes, es MPI (message-passing interface).

Introducción

MPI es, básicamente, una librería (grande) de funciones de comunicación para el envío y recepción de mensajes entre procesos.

MPI indica explicitamente la comunicación entre procesos, es decir:

-- los movimientos de datos-- la sincronización


MPI 349

Dos tipos de comunicación:

• punto a punto • global

El modelo de paralelismo que implementa MPI es SPMD.

if (pid == 1) ENVIAR_a_pid2

else if (pid == 2) RECIBIR_de_pid1

Recuerda: cada proceso dispone de su propio espacio independiente de direcciones.

Tipos de comunicación


MPI 359

Modos de comunicación (1)

• síncronaLa comunicación no se produce hasta que emisor y receptor se ponen de acuerdo.

• mediante un búferEl emisor deja el mensaje en un búfer y retorna. La comunicación se produce cuando el receptor está dispuesto a ello. El búfer no se puede reutilizar hasta que se vacíe.



MPI 369

Modos de comunicación (2)

• bloqueanteSe espera a que la comunicación se produzca.La comunicación síncrona es siempre bloqueante. En el caso buffered, existen ambas alternativas.

• no bloqueanteSe retorna y se continúa con la ejecución. Más adelante, se comprueba si la comunicación ya se ha efectuado.



MPI 379

Cada estrategia tiene sus ventajas e inconvenientes:> síncrona: es más rápida si el receptor está

dispuesto a recibir; nos ahorramos la copia en el buffer. Además del intercambio de datos, sirve para sincronizar los procesos.Ojo: al ser bloqueante es posible un deadlock!

> buffered: el emisor no se bloquea si el receptor no está disponible, pero hay que hacer copia(s) del mensaje (más lento).



MPI 389

MPI gestiona los procesos estáticamente (número y asignación) (MPI2 también dinámicamente). Cada proceso tiene un identificador o pid.

MPI agrupa los procesos implicados en una ejecución paralela en “comunicadores”. Un comunicador agrupa a procesos que pueden intercambiarse mensajes.

El comunicador MPI_COMM_WORLD está creado por defecto y engloba a todos los procesos.

Introducción


MPI 399

Aunque MPI consta de más de 300 funciones, el núcleo básico lo forman sólo 6:

2 de inicio y finalización del programa.2 de control del número de procesos.2 de comunicación.

Sintaxis: MPI_Funcion(…)

Funciones básicas


MPI 409

1. Comienzo y final del programa:

> MPI_Init(&argc, &argv);

> MPI_Finalize();

Estas dos funciones son la primera y última función MPI que deben ejecutarse en un programa.

F. básicas: Init / Finalize


MPI 419

2. Identificación de procesos

> MPI_Comm_rank(comm, &pid);

Devuelve en pid el identificador del proceso dentro del comunicador comm especificado. Los procesos se identifican mediante dos parámetros: el pid y el grupo (comm, p.e., MPI_COMM_WORLD).

> MPI_Comm_size(comm, &npr);

Devuelve en npr el número de procesos del comunicador comm.

F. básicas: Comm_rank / _size


MPI 429

Un ejemplo sencillo

#include <stdio.h>#include <mpi.h>

main (int argc, char *argv[]){

int pid, npr, A = 2;

MPI_Init(&argc, &argv);

MPI_Comm_rank(MPI_COMM_WORLD, &pid);MPI_Comm_size(MPI_COMM_WORLD, &npr);

A = A + 1;

printf(“Proc. %d de %d activado, A = %d\n”, pid,npr,A);

MPI_Finalize();}

Funciones básicas


MPI 439

3. Envío y recepción de mensajes

La comunicación entre procesos necesita (al menos) de dos participantes: el emisor y el receptor.

El emisor ejecuta la función de envío de mensajes, y el receptor la de recepción.

A Benviar recibir

La comunicación es un proceso cooperativo. Si una de las dos funciones no se ejecuta, la comunicación no tiene lugar (y podría producirse un deadlock!).

F. básicas: Send / Receive


MPI 449

> MPI_Send(&mess, count, type, dest,

tag, comm);

- mensaje: [mess (@com), count (tamaño), type]

- receptor: [dest, comm (grupo)]

- tag: dato de control, de 0 a 32767 (tipo de mensaje, orden...)

Función básica para enviar un mensaje:



MPI 459

> MPI_Recv(&mess, count, type, source, tag, comm, &status);

- mensaje (espacio): [mess, count, type]

- emisor: [source, comm]

- tag: clase de mensaje...

- status: información de control sobre el mensaje recibido

Función básica para recibir un mensaje:

Recv se bloquea hasta que se recibe el mensaje.



MPI 469

...#define N 10int main (int argc, char **argv){int pid, npr, orig, dest, ndat, tag;int i, VA[N];MPI_Status info;

MPI_Init(&argc, &argv);MPI_Comm_rank(MPI_COMM_WORLD,&pid);

for (i=0;i<N;i++) VA[i] = 0;

if (pid == 0) {

for (i=0;i<N;i++) VA[i] = i;

dest = 1; tag = 0;MPI_Send(VA, N, MPI_INT, dest, tag,

MPI_COMM_WORLD);}

else if (pid == 1) {

for (i=0;i<N;i++) printf(“%4d”,VA[i]);

orig = 0; tag = 0;MPI_Recv(VA, N, MPI_INT, orig, tag,

MPI_COMM_WORLD, &info);

MPI_Get_count(&info, MPI_INT, &ndat);

printf(“Datos de pr%d; tag = %d, ndat = %d \n”, info.MPI_SOURCE, info.MPI_TAG, ndat);

for (i=0;i<ndat;i++) printf(“%4d”,VA[i]);

}

MPI_Finalize();

}

Ejemplo


MPI 479

Síncrono:MPI_Ssend

(&mes,count,datatype,dest,tag,comm);

Ssend no devuelve control hasta que el receptor comienza la lectura.

Inmediato:

MPI_Isend (...);

Retorna nada más ejecutarse; luego, para saber si se ha producido o no la comunicación:

MPI_Test (...) devuelve 0 o 1MPI_Wait (...) espera a que finalice

Más tipos de Send / Receive


MPI 489

Muchas aplicaciones requieren de operaciones de comunicación en las que participan muchos procesos. La comunicación es colectiva si participan en ella todos los procesos del comunicador.

Ejemplo: un broadcast, envío de datos desde un proceso a todos los demás.¿Uno a uno en un bucle?

Comunicaciones colectivas


MPI 499

Las funciones de comunicación colectiva son bloqueantes.Todos los procesos que forman parte del comunicador deben ejecutar la función.

Tres tipos

1 Movimiento de datos2 Operaciones en grupo3 Sincronización



MPI 509

1a Broadcast: envío de datos desde un proceso (root) a todos los demás.

AP0

P2 P3

P1

A A

A

(implementación logarítmica en árbol)

AP0

P2 P3

P1

> MPI_Bcast(&mess, count, type, root, comm);

CC: movimento de datos


MPI 519

ABCDP0

P2 P3

P1A B C

DP0

P2 P3

P1

1b Scatter: reparto de datos desde un proceso al resto

C

B

D

A

AP0

P2 P3

P1

C D

B AP0

P2 P3

P1

C D

B ABCD

1c Gather: recolección de datos de todos los procesos

CC: movimento de datos


MPI 529

2. Reduce (en árbol)

Allreduce: todos obtienen el resultado (Reduce + BC)

KK: operaciones en grupo

AP0

P2 P3

P1

C D

B AP0

P2 P3

P1

C D

BA+B+C+D


MPI 539

3. Barreras de sincronización

Sincronización global entre todos los procesos del comunicador.

MPI_Barrier (comm);

La función se bloquea hasta que todos los procesos del comunicador la ejecutan.

CC: sincronización


MPI 549

> Ejemplo: V(i) = V(i) * V(j)sum = 0;

for (j=0; j<N; i++) sum = sum + V[j];

for (i=0; i<N; i++) V[i] = V[i] * sum;

1. Leer N (el pid = 0)2. Broadcast de N/npr (tamaño del vector local)3. Scatter del vector V (trozo correspondiente)4. Cálculo local de la suma parcial5. Allreduce de sumas parciales (todos obtienen suma total)6. Cálculo local de V(i) * sum7. Gather de resultados8. Imprimir resultados (el pid = 0)



MPI 559

#include <stdio.h>#include <mat.h>#include “mpi.h”

int main (int argc, char **argv){int pid, npr, i, n;double PI = 3.1415926536;

double h, ×, pi_loc, pi_glob, sum;

MPI_Init(&argc, &argv);MPI_Comm_rank(MPI_COMM_WORLD,&pid);MPI_Comm_size(MPI_COMM_WORLD,&npr);

if (pid == 0) { printf(“ Núm de intervalos”; scanf("%d",&n); }

MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);

h = 1.0 / (double) n;sum = 0.0;for (i=pid; i<n; i+=npr){x = (i + 0.5) * h;sum += 4.0 / (1.0 + x*x);

}pi_loc = h * sum;

MPI_Reduce(&pi_loc, &pi_glob, 1, MPI_DOUBLE, MPI_SUM, 0,

MPI_COMM_WORLD);

if (pid == 0)printf("pi(+/-) = %.16f, error = %.16f\n", pi_glob, fabs(pi_glob - PI));

MPI_Finalize();}

Ej.: cálculo del número pi


MPI 569

De libre distribución: MPICH / LAM

En general, previo a la ejecución en paralelo en un máquina tipo cluster, se necesita:

- un fichero con la lista de máquinas que conforman el sistema (identificadores en la red).

- unos daemons que se ejecuten en cada máquina.

- indicar, al ejecutar, el número concreto de procesos que se desea generar:

mpiexec -n 8 pi

Implementaciones de MPI


MPI 579

TEXTOS

• P. S. Pacheco: Parallel Programming with MPI. Morgan Kaufmann, 1997.

• W. Groop et al.: Using MPI. Portable Parallel Programming with the Message Passing Interface (2. ed.).

MIT Press, 1999.

• M. Snir et al.: MPI - The complete reference (vol. 1 y 2).

The MIT Press, 1998.

WEB

• www-unix.mcs.anl.gov/mpi/ (todo)

Más información

Arquitecturas Paralelas IF - EHU Arquitecturas Paralelas 9. Herramientas para la programación de...

Documents

Transcript of Arquitecturas Paralelas IF - EHU Arquitecturas Paralelas 9. Herramientas para la programación de...