. 5 . OTRAS ALTERNATIVAS: Unified Parallel C (resumen). ghjghjghhj.

Presentación del tema: ". 5 . OTRAS ALTERNATIVAS: Unified Parallel C (resumen). ghjghjghhj."— Transcripción de la presentación:

1 . 5 . OTRAS ALTERNATIVAS: Unified Parallel C (resumen). ghjghjghhj

2 Índice 1. Introducción. 2. Variables y punteros. Movimiento de datos. Memoria dinámica. 3. Reparto de tareas (work sharing). 4. Sincronización y consistencia. 5. Librería de operaciones colectivas. 6. Conclusiones.

3 Introducción  Las dos herramientas habituales para desarrollar aplicaciones paralelas son OpenMP, para el caso de sistemas SMP de memoria compartida, y MPI, para las arquitecturas de memoria distribuida (también para memoria compartida).  En general, es más fácil programar aplicaciones paralelas de memoria compartida que de memoria distribuida; sin embargo, es mas fácil (barato) disponer de un sistema tipo cluster (memoria distribuida) con muchos procesadores que de una máquina SMP (MPP) de muchos procesadores.

4  Otra alternativa: UPC (Unified Parallel C)
Introducción  Otra alternativa: UPC (Unified Parallel C) Herramienta para desarrollar aplicaciones paralelas de memoria compartida (como OpenMP), pero para sistemas de memoria distribuida (p.e., una red de PCs) y sin tener que explicitar la comunicación. Una extensión de C que permite efectuar operaciones rd/wr sobre memoria local y sobre memoria remota. MPI también permite efectuar operaciones de “comunicación” one-sided, put y get, para poder leer o escribir unilateralmente en la memoria “privada” de otro nodo.

5 Introducción  Cuando es necesario acceder a una porción de memoria no local, en otro nodo del sistema, la comunicación entre nodos se efectúa de manera implícita. En nuestro cluster, para ejecutar programas UPC, igual que en el caso MPI, necesitamos que estén en ejecución en cada nodo del sistema los daemons mpd. Versión 2.14, octubre 2011 (Berkeley)

6  Modelo de memoria distribuida: MPI
Introducción  Modelo de memoria distribuida: MPI • Procesos con su memoria local • Comunicación explícita (send / receive) P C M red general R Pros / contras + Control del reparto de carga y de datos + Fácil de escalar – Sobrecarga de comunicación (pocos datos) – Más difícil de programar

7  Modelo de memoria compartida: OpenMP
Introducción  Modelo de memoria compartida: OpenMP • Conjunto de threads/procesos, único espacio de direccionamiento • Comunicación mediante rd y wr M P C bus Pros / contras + Programación más sencilla + Comunicación sencilla entre procesos – Datos compartidos → Sincronización – “No aprovecha la localidad” – Más difícil de escalar

8  Modelo de mem. compartida distribuida (PGAS): UPC
Introducción  Modelo de mem. compartida distribuida (PGAS): UPC • Similar al modelo de memoria compartida • Los threads tienen afinidad con partes de memoria Pros / contras + Programación y comunicación entre procesos más sencilla + Aprovechamiento de la localidad (affinity) + Más fácil de escalar – Sincronización P C M red general R

9  UPC: reparto de la memoria entre los threads
Introducción  UPC: reparto de la memoria entre los threads • Un programa UPC define un grupo de threads que se ejecutan en un espacio de direccionamiento único, pero que está distribuido entre ellos. • La memoria del sistema se divide en dos partes: una zona compartida y una zona privada. Cada thread tiene acceso a su parte de la memoria privada y a la memoria compartida por todos los threads. • Las variables que se encuentran en la memoria asignada a cada thread (privada o compartida) tienen afinidad (affinity) con dicho thread.

10  UPC: reparto de la memoria entre los threads
Introducción  UPC: reparto de la memoria entre los threads T T T T4 privada compartida

11  UPC: reparto de la memoria entre los threads
Introducción  UPC: reparto de la memoria entre los threads • Todos los threads pueden acceder a cualquier posición de la memoria compartida, por lo que la comunicación entre procesos es sencilla. • Pero, ojo, el tiempo de acceso a las diferentes zonas de memoria va a ser muy diferente, en función de dónde se encuentre físicamente dicha memoria: en el propio nodo (porción de memoria con la que tiene afinidad) o en otro nodo de la red.

12  UPC incluye (entre otras cosas)
Introducción  UPC incluye (entre otras cosas) • un par de variables reservadas que representan el número total de threads en ejecución, THREADS, y el identificador de cada thread, MYTHREAD. • un método para repartir los datos entre los procesos, más un mecanismo para reparto estático de las iteraciones de bucles (work sharing): upc_forall. • funciones para sincronizar threads (barreras y locks). • funciones para mover bloques de datos entre threads. • funciones de comunicación global: broadcast, scatter, gather...

13  Para compilar y ejecutar programas UPC
Introducción  Para compilar y ejecutar programas UPC Diferentes opciones, dependiendo de la implementación; el programa fuente puede ser .upc o .c. Añadir al comienzo #include <upc.h> • Definir el número de threads al compilar (más optimizado) > upcc –T=4 –o pr1 pr1.upc > upcrun pr1 • Definir el número de threads al ejecutar (más “flexible”) > upcc –o pr1 pr1.upc > upcrun –n 4 pr1 Ojo! en este caso, el reparto de las variables a los threads no debe depender del número de threads.

14 Introducción  Ejemplo: hola.upc #include <upc.h>
#include <stdio.h> int main() { int X = 0; if (MYTHREAD == 1) X = 1; printf("\n Thread %d (de %d) X = %d \n\n", MYTHREAD, THREADS, X); return(0); }

15 2. Variables y punteros. Movimiento de datos. Memoria dinámica.
Índice 1. Introducción. 2. Variables y punteros. Movimiento de datos. Memoria dinámica. 3. Reparto de tareas (work sharing). 4. Sincronización y consistencia. 5. Librería de operaciones colectivas. 6. Conclusiones.

16 Variables y punteros  Dado el modelo de memoria, las variables de un programa UPC pueden ser privadas o compartidas. • Por defecto las variables son privadas, y se crea una copia de cada una de ellas en la zona de memoria privada de cada thread. • Las variables compartidas (static) se declaran como shared, y se definen en la zona de memoria común. En la propia declaración de la variable se indica la afinidad de la misma; es decir, en la memoria asignada a qué thread hay que cargarla.

17 Variables y punteros • Si la variable shared es un escalar, se asigna a la memoria afín al thread 0. Si es un array, se va repartiendo entre los threads, con el nivel de entrelazado (block size) que se indica en la propia definición. • La definición general de un vector (matriz...) compartido es: shared [tam_bloq] tipo vector[tam]; Si no se indica el tamaño de bloque, el reparto es elemento a elemento. Si se indica [], todo el vector va al thread 0. [*] hace que cada thread tenga un trozo del mismo tamaño (salvo quizás el último, que puede ser más pequeño).

18 Variables y punteros • El elemento i de un vector shared tiene afinidad con el thread (es decir, está cargado en la memoria asignada al thread): (i / tam_bloq) mod THREADS donde tam_bloq es el tamaño del “entrelazado” de los elementos del vector entre los threads.

19 Variables y punteros  Ejemplos
int X; variable privada, cada thread una copia shared int Y; variable compartida, en el thread 0 shared [ ] float V1[N]; todo el vector V1 en el thread 0 shared float V2[N]; reparto 1 a 1 = shared [1] float V2[N] shared [N/THREADS] float V3[N]; reparto por trozos de tamaño N/THREADS shared [N] int A[N][N]; reparto de la matriz por filas

20 Variables y punteros  Ejemplos (4 threads) T0 T1 T2 T3 X X X X
zona de memoria privada zona de memoria común T0 T1 T2 T3 X X X X int X; shared int MIN; MIN shared [2] int A[8]; A0 A2 A4 A6 A1 A3 A5 A7 shared [] int B[2]; B0 B1

21 ¿Dónde está la variable apuntada?
Variables y punteros  En UPC se definen cuatro tipos de punteros, en función de dónde estén y adónde apunten (zona compartida / zona privada). ¿Dónde está el puntero? Private Shared PP PS SP SS ¿Dónde está la variable apuntada?

22 Variables y punteros  Ejemplos de punteros
int *P1; Puntero en zona privada apuntando a zona privada (PP). Acceso a datos privados. shared int *P2; Puntero en zona privada apuntando a zona compartida (SP). Acceso del thread local a un dato shared. int *shared P3; Puntero en zona compartida apuntando a zona privada. (PS, no utilizar). shared int *shared P4; Puntero en zona compartida apun-tando a zona compartida (SS). Acceso de cualquier thread a un dato shared.

23 Variables y punteros  Ejemplos de punteros Thread i P1 P2 private
shared P4

24  Formato de un puntero (una dirección de memoria)
Variables y punteros  Formato de un puntero (una dirección de memoria) fase thread dirección bloque Dos (tres) campos definen un puntero UPC a shared: - la dirección a la que apunta, en dos partes: dirección del bloque de memoria, y dirección de la palabra apuntada dentro del bloque (fase). - el thread al que apunta (aquel que tiene afinidad con la dirección apuntada).

25  Formato de un puntero (una dirección de memoria)
Variables y punteros  Formato de un puntero (una dirección de memoria) Tres funciones permiten obtener los tres paráme-tros que definen el puntero: > void *upc_addrfield (shared void *P) dirección del bloque apuntado por P > int upc_phaseof (shared void *P) fase (posición dentro del bloque) > int upc_threadof (shared void *P) thread con afinidad con el objeto apuntado

26 Variables y punteros • De cara a mejorar la eficiencia en los accesos a memoria, se puede convertir (hacer un casting) un puntero shared que apunta a un objeto shared en un puntero privado, siempre que el objeto compartido esté en el mismo thread. • La aritmética de punteros tiene en cuenta cómo se han distribuido los datos entre los threads (es decir, se hace dato a dato, no thread a thread), para lo que el puntero tiene que declararse con el mismo tamaño de bloque que los datos.

27 Variables y punteros T0 T1 T2 T3 P S #define N 16 shared int A[N]
shared int *p1, *p2 p1 = &A[5]; p2 = p1 + 9; S P T0 T1 T2 T3 p1 p1 p1 p1 p2 p2 p2 p2 A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 p1 p2

28 Variables y punteros T0 T1 T2 T3 P S #define N 16 shared int A[N]
shared int *shared p1 shared int *p2 p1 = &A[5]; p2 = &A[MYTHREAD]; S P T0 T1 T2 T3 p2 p2 p2 p2 A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 p1

29 Variables y punteros T0 T1 T2 T3 P S #define N 16
shared [3] int A[N],*p1,*p2; shared int *p3 p1 = &A[5]; p2 = p1 + 4; p3 = p1 + 3; T0 T1 T2 T3 p1 p1 p1 p1 p2 p2 p2 p2 p3 p3 p3 p3 P p2 A0 A3 A6 A9 A1 A4 A7 A10 A2 A5 A8 A11 A12 A15 A13 A14 p1 S p3

30 Movimiento de datos  La gestión de la memoria, distribuida entre los procesos en zonas privadas y zonas compartidas, es uno de los puntos complejos de UPC. Por ello, UPC proporciona unas cuantas funciones para mover bloques de datos entre diferentes zonas de la memoria, similares a las correspondientes funciones de C, de manera más eficiente que hacerlo dato a dato.

31 Movimiento de datos • Para copiar datos (equivalente a memcpy):
> upc_memcpy(dest, orig, tam) //tam en bytes copia de zona shared a zona shared > upc_memput(dest, orig, tam) copia de zona private a zona shared > upc_memget(dest, orig, tam) copia de zona shared a zona private • Para inicializar una zona de memoria (memset): > upc_memset(dest, char, tam) inicializa memoria shared con char

32  Funciones UPC para la gestión dinámica de la memoria
Memoria dinámica  Funciones UPC para la gestión dinámica de la memoria • Recordad: cada thread tiene una zona de memoria privada, y una zona de memoria compartida accesible por todos los threads. • Para el caso de la memoria privada de cada thread se utilizan las mismas funciones que en C. • Para el caso de memoria compartida (shared) las funciones de reserva de memoria pueden ser globales –colectivas o individuales- o locales.

33 Memoria dinámica • Funciones globales (reservan memoria en todos los threads): a. Colectiva: debe ser llamada por todos los threads > shared void *upc_all_alloc (nblq, nbytes); Los nblq bloques de nbytes de memoria se reparten r.r. entre los threads (parámetros de tipo size_t). Devuelve un puntero a shared, el mismo en todos los threads, que luego podemos asignar, por ejemplo, a un puntero privado en cada thread.

34 Memoria dinámica • Funciones globales (reservan memoria en todos los threads): b. Individual: sólo la threads > shared void *upc_global_alloc (nbloq, nbytes); El thread que ejecuta la función recibe un puntero a un bloque de datos shared, de tamaño nbloq × nbytes, repartido por todos los threads.

35 Memoria dinámica • Ejemplos: shared [N] int *ptr;
ptr = (shared [N] int*) upc_all_alloc(THREADS,N*sizeof(int)); ptr S P shared [N] int *ptr; ptr = (shared [N] int*) upc_global_alloc(THREADS,N*sizeof(int)); ptr S P

36 Memoria dinámica • Función local (reserva memoria sólo en la parte shared del thread que ejecuta la función): > shared void *upc_alloc (nbytes); Devuelve un puntero al bloque de datos shared de la memoria afín. • Para liberar memoria: > void upc_free (shared void *ptr);

37 3. Reparto de tareas (work sharing).
Índice 1. Introducción. 2. Variables y punteros. Movimiento de datos. Memoria dinámica. 3. Reparto de tareas (work sharing). 4. Sincronización y consistencia. 5. Librería de operaciones colectivas. 6. Conclusiones.

38 Reparto de tareas (work sharing)
 UPC sólo dispone de un constructor para repartir tareas; en concreto, las iteraciones de un bucle for, de forma estática.  El modelo de reparto es SPMD, y se busca favorecer la localidad en los accesos (afinidad), teniendo en cuenta cómo están distribuidos los datos (declaración de variables).  No se efectúa ningún análisis de dependencias. Las iteraciones deben ser independientes, ya que no se controla el orden de ejecución.

39  El constructor de reparto de las iteraciones de un bucle es:
Reparto de tareas  El constructor de reparto de las iteraciones de un bucle es: upc_forall (inic; fin; incr; afinidad) El parámetro de afinidad indica qué thread ejecutará la iteración correspondiente. Puede ser: - un entero (n); la iteración del bucle se asigna al thread n % THREADS. - una dirección (&A); la iteración se asigna al thread que tiene afinidad con esa dirección (al que tiene la variable en su zona de memoria).

40 Reparto de tareas  Ejemplos:
upc_forall(i=0; i<N; i++; i) A[i] = A[i] + 1; El parámetro de afinidad indica que el reparto va a ser entrelazado, iteración a iteración, ya que el bucle equivale a: for (i=0; i<N; i++) if (MYTHREAD == i % THREADS) A[i] = A[i] + 1;

41 Reparto de tareas  Ejemplos:
upc_forall(i=0; i<N; i++; i*THREADS/N) A[i] = A[i] + 1; Ahora el reparto de las iteraciones es consecutivo. upc_forall(i=0; i<N; i++; &A[i]) A[i] = A[i] + 1; La iteración i la ejecutará el thread que tenga afinidad con A[i], es decir el que tenga la variable en “su” memoria.

42 Reparto de tareas  Para el caso de bucles anidados, sólo se repartirá la ejecución del bucle upc_forall más externo; el resto se repetirá en todos los threads.  Si no se indica el parámetro de afinidad, todos los threads ejecutarán todas las iteraciones del bucle upc_forall.  upc_forall no lleva una barrera de sincronización al final; si se necesita, hay que añadir la correspondiente función.

43 Reparto de tareas  Ejemplo A se reparte por filas
#include <upc.h> #define N 100*THREADS; shared [N] double A[N][N] shared double B[N], X[N] void main (int argc, char **argv) { int i, j; /* inicializaciones */ upc_forall (i=0; i<N; i++; i) for (j=0; j<N; j++;) B[i] += A[i][j] * X[j]; } 1 elemento de B y de X por thread (round robin) reparto estático entrelazado 1 accesos i locales

44 4. Sincronización y consistencia.
Índice 1. Introducción. 2. Variables y punteros. Movimiento de datos. Memoria dinámica. 3. Reparto de tareas (work sharing). 4. Sincronización y consistencia. 5. Librería de operaciones colectivas. 6. Conclusiones.

45 Sincronización y consistencia
 Al utilizarse un modelo de memoria compartida, es necesario disponer de algún mecanismo para poder sincronizar el acceso de los threads a las variables compartidas (cerrojos) y para sincronizar la ejecución de los threads de manera global (barreras).  Además, debemos conocer (y poder controlar) el modelo de consistencia de la memoria bajo el cual se van a ejecutar los programas.

46 Sincronización y consistencia
 Funciones de sincronización que ofrece UPC: 1 Barreras (dos tipos) - bloqueante: upc_barrier; - no bloqueante: upc_notify; upc_wait; (para solapar cálculo y sincronización) (pueden llevar un entero -o una expresión que se evalúe a un entero- para identificar unas llamadas de otras: upc_notify 1)

47 Sincronización y consistencia
 Funciones de sincronización que ofrece UPC: 2 Cerrojos Las variables cerrojo son de tipo upc_lock_t, sólo manejables a través de punteros: upc_lock_t *C; Para crear un puntero a un cerrojo: todos: C = upc_all_lock_alloc(); uno: C = upc_global_lock_alloc(); Para liberar memoria del cerrojo: upc_lock_free(C);

48 Sincronización y consistencia
 Funciones de sincronización que ofrece UPC: 2 Cerrojos Las dos funciones típicas con cerrojos: upc_lock(C); upc_unlock(C); Para mirar cómo está el cerrojo: upc_lock_attempt(C); 1: acierto / 0: fallo

49 Sincronización y consistencia
 Modelo de consistencia. Recordad: > orden de los accesos a memoria > cuándo se ven los cambios de las variables compartidas UPC pemite trabajar con los dos modelos típicos de consistencia: - strict: orden secuencial estricto de las operaciones de memoria: todos ven los cambios antes de poder acceder (no se optimiza!). - relaxed: accesos no “controlados” (por defecto, como si sólo hubiera un proceso); el usuario debería sincronizarlos.

50 Sincronización y consistencia
 Modelo de consistencia Podemos definir la consistencia: • para todo el programa #include <upc_strict/relaxed.h> • para un bloque básico concreto del programa #pragma upc strict/relaxed • para una variable en concreto strict shared int X;

51 Sincronización y consistencia
 Modelo de consistencia Como siempre, a veces es necesario imponer orden estricto en un programa en el que la consistencia es relajada, para lo que hay que usar una ”barrera” de ordenación (fence): upc_fence; Todos los accesos a variables shared previos han terminado antes de proceder con accesos posteriores. Recuerda: el modelo de consistencia estricto puede tener consecuencias importantes en el rendimiento del sistema.

52 strict shared int A, flag;
Sincronización y consistencia  Por ejemplo: #include <upc_relaxed.h> ... flag = 0; if (MYTHREAD==0) { A = ...; flag = 1; } else { while(flag==0) { }; ... = A; #include <upc_relaxed.h> shared int A, flag; ... flag = 0; { if (MYTHREAD==0) { A = ...; flag = 1; } else { while(flag==0) { }; ... = A; #include <upc_relaxed.h> shared int A, flag; ... flag = 0; if (MYTHREAD==0) { A = ...; flag = 1; } else { while(flag==0) { }; ... = A; strict shared int A, flag; #pragma upc strict upc_fence;

53 5. Librería de operaciones colectivas.
Índice 1. Introducción. 2. Variables y punteros. Movimiento de datos. Memoria dinámica. 3. Reparto de tareas (work sharing). 4. Sincronización y consistencia. 5. Librería de operaciones colectivas. 6. Conclusiones.

54 Operaciones colectivas
 UPC ofrece una librería con las típicas operaciones colectivas para “intercambio” de datos (de memoria compartida a memoria compartida) entre todos los threads. Al ser una función colectiva, tiene que ser ejecutada por todos los threads de la aplicación. Para poder utilizarlas, hay que añadir en el programa: #include <upc_collective.h> Veamos las prinicipales funciones de este tipo que ofrece UPC (para más información, referirse al manual).

55 Operaciones colectivas
1 Broadcast Copia un bloque de memoria shared de un determinado thread a un bloque de memoria shared en cada uno de los threads. > upc_all_broadcast(*dest,*orig,tam,sync_model) *dest, *orig: punteros a zona de memoria shared tam: tamaño del bloque de datos en bytes sync_model: variable de tipo upc_flag_t, para indicar cómo se sincronizan los procesos.

56 Operaciones colectivas
1 Broadcast Copia un bloque de memoria shared de un determinado thread a un bloque de memoria shared en cada uno de los threads. > upc_all_broadcast(*dest,*orig,tam,sync_model) El modo de sincronización es un or de dos constantes: UPC_IN_XSINC | UPC_OUT_YSINC donde X e Y pueden ser: NO: se empieza a leer/escribir en cuanto llega un thread MY: sólo se leen/escriben datos afines a quienes ya han llegado ALL: esperamos a todos para empezar / acabar

57 Operaciones colectivas
2 Scatter Reparto de datos: copia el bloque i de una zona de memoria shared de un determinado thread a un bloque de memoria shared afín al thread i. > upc_all_scatter(*dest,*orig,tam,sync_model) *dest, *orig: punteros a zona de memoria shared tam: tamaño del trozo que se reparte sync_model: como en el caso anterior

58 Operaciones colectivas
3 Gather Recoge en memoria shared de un determinado thread bloques de memoria shared de todos los threads. > upc_all_gather(*dest,*orig,tam,sync_model) > upc_all_gather_all(*dest,*orig,tam,sync_model) (operación gather en la que el resultado final se copia en la memoria shared afín de cada thread).

59 Operaciones colectivas
4 Exchange Efectúa una transposición de bloques de datos entre todos los threads. > upc_all_exchange(*dest,*orig,tam,sync_model) T0: D0 D1 D2 T1: D3 D4 D5 T2: D6 D7 D8 T0: D0 D3 D6 T1: D1 D4 D7 T2: D2 D5 D8 5 Permute Efectúa una permutación de bloques de datos entre los threads. > upc_all_permute(*dest,*orig,*perm,tam, sync_model)

60 Operaciones colectivas
6 Reduce Operación (conmutativa) típica de reducción de datos. > upc_all_reduceT(...) 7 Otras > upc_all_prefix_reduce(...) > upc_all_sort(...)

61 6. Conclusiones. Índice 1. Introducción.
2. Variables y punteros. Movimiento de datos. Memoria dinámica. 3. Reparto de tareas (work sharing). 4. Sincronización y consistencia. 5. Librería de operaciones colectivas. 6. Conclusiones.

62 Conclusiones  UPC combina el modelo de programación de memoria compartida, más intuitivo, con el uso de paso de mensajes, lo que permite utilizar máquinas paralelas más escalables y de coste reducido.  UPC no es muy complejo de utilizar, sobre todo para programadores habituados a trabajar con C. No hemos visto todas las funciones; p.e., hay un grupo de funciones para trabajar la entrada/salida paralela.  Añade cierta sobrecarga a los programas que, por otra parte, serían más difíciles de programar directamente en MPI. Hay que optimizar bien el código.

63  Para obtener un buen rendimiento con UPC
(MB/s) rd wr CC 640.0 400.0 UPC private 686.0 565.0 UPC shared local 7.0 44.0 UPC shared remote 0.2 + Utilizar punteros privados para acceder a datos afines compartidos. + Utilizar las funciones para copiar bloques de datos. + Solapar accesos remotos con procesamiento local.

64  Para obtener un buen rendimiento con UPC
-- Compilar con la opción –opt, para aplicar las optimizaciones típicas del compilador (sio no están implementadas las optimizaciones habituales –O). -- Si la arquitectura de la máquina es SMP, se pueden compilar los programas con la opción –smp_local. De esa manera se permite que cualquier thread acceda a la memoria compartida de cualquier otro thread como si fuera privada (dada la arquitectura del sistema, no es necesaria la comunicación).

65 Resumen final (i) OpenMP MPI UPC Modelo de programación
memoria compartida paso de mensajes memoria compartida distribuida Lenguajes C / Fortran C Expresión del paralelismo directivas y funciones librería de funciones extensión de C, funciones Arquitecturas SMP MIMD + SMP Topologías virtuales --- sí

66 reparto de datos explícito
Resumen final (ii) OpenMP MPI UPC Grado de paralelismo variable v. ent. / func. fijo mpirun –np comp. / ejec. Paralelismo anidado sí no Aprovechamiento de la localidad datos --- difícil reparto de datos explícito sí (afinidad) Operaciones colectivas Broadcast Scatter/Gather Reduction-

67 Resumen final (iii) OpenMP MPI UPC Planificación (work sharing) sí
estát. / dinám. costosa afin. forall Declaraciones: distrib. de datos --- no decl. de arrays por bloques Control de la consistencia compilador strict/relaxed progr., inst., vble. Sincronización sec. cr., locks, barreras, single barreras barreras, locks Gestión de memoria dinámica dentro de cada thread sólo privada privada/comp. vble. y bloque

68  Páginas web de UPC (con toda la información)
Referencias  Páginas web de UPC (con toda la información) upc.lbl.gov (Berkeley Univ.) upc.gwu.edu (George Washington Univ.) (gcc UPC)  Libro UPC: Distributed Shared Memory programming T. El-Ghazawi, W. Carlson, T. Sterling, K. Yelick J. Wiley, 2005.

69 Informatika Fakultatea Euskal Herriko Unibertsitatea
Títulos de crédito paralelismokolaborategialaboratoriodeparalelismo Javier Muguerza & Agustin Arruabarrena Konputagailuen Arkitektura eta Teknologia Arquitectura y Tecnología de Computadores Informatika Fakultatea Euskal Herriko Unibertsitatea EHU - KAT 2012ko maiatza