5 . o tras a lternativas: u nified p arallel c (resumen )
DESCRIPTION
. 5 . O TRAS A LTERNATIVAS: U nified P arallel C (resumen ). Í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. - PowerPoint PPT PresentationTRANSCRIPT
Laboratorio de ParalelismoIF - EHU
. 5 .OTRAS ALTERNATIVAS:
Unified Parallel C (resumen).
Laboratorio de ParalelismoIF - EHU
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.
Índice
Laboratorio de ParalelismoIF - EHU
UPC 35
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.
Introducción
Laboratorio de ParalelismoIF - EHU
UPC 45
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.
Introducción
Laboratorio de ParalelismoIF - EHU
UPC 55
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)
Introducción
Laboratorio de ParalelismoIF - EHU
UPC 65
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
Introducción
Laboratorio de ParalelismoIF - EHU
UPC 75
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
Introducción
Laboratorio de ParalelismoIF - EHU
UPC 85
P
C
M
red general
R
Modelo de mem. compartida distribuida (PGAS): UPC• Similar al modelo de memoria compartida• Los threads tienen afinidad con partes de memoriaPros / contras+ Programación y comunicación entre procesos más sencilla+ Aprovechamiento de la localidad (affinity)+ Más fácil de escalar
– Sincronización
Introducción
Laboratorio de ParalelismoIF - EHU
UPC 95
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.
• Las variables que se encuentran en la memoria asignada a cada thread (privada o compartida) tienen afinidad (affinity) con dicho thread.
• 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.
Introducción
Laboratorio de ParalelismoIF - EHU
UPC 105
UPC: reparto de la memoria entre los threads
T1 T2 T3 T4
privada
compartida
Introducción
Laboratorio de ParalelismoIF - EHU
UPC 115
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.
Introducción
Laboratorio de ParalelismoIF - EHU
UPC 125
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...
Introducción
Laboratorio de ParalelismoIF - EHU
UPC 135
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.
Introducción
Laboratorio de ParalelismoIF - EHU
UPC 145
#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);}
Ejemplo: hola.upc
Introducción
Laboratorio de ParalelismoIF - EHU
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.
Índice
Laboratorio de ParalelismoIF - EHU
UPC 165
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.
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 175
• 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).
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 185
• 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.
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 195
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
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 205
---------------------
zona de memoria privada
zona de memoria común
T0 T1 T2 T3
Ejemplos (4 threads)
int X; X X X X
A0 A2 A4 A6
A1 A3 A5 A7
B0
B1
MIN
shared [2] int A[8];
shared [] int B[2];
shared int MIN;
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 215
En UPC se definen cuatro tipos de punteros, en función de dónde estén y adónde apunten (zona compartida / zona privada).
Private Shared
Private PP PS
Shared SP SS
¿Dónde está el puntero?
¿Dónde está la variable
apuntada?
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 225
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.
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 235
Ejemplos de punteros
private
shared
P4P3
Thread i
P1 P1 P1P2 P2 P2
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 245
Formato de un puntero (una dirección de memoria)
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).
fase
thread
dirección bloque
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 255
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
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 265
• 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.
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 275
S
P
T0 T1 T2 T3
#define N 16shared int A[N]shared int *p1, *p2
p1 = &A[5];p2 = p1 + 9;
p1
p2
p1 p1 p1 p1p2 p2 p2 p2
A0 A1 A2 A3A4 A5 A6 A7A8 A9 A10 A11A12 A13 A14 A15
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 285
S
P
T0 T1 T2 T3
#define N 16shared int A[N]shared int *shared p1shared int *p2
p1 = &A[5];p2 = &A[MYTHREAD];
A0 A1 A2 A3A4 A5 A6 A7A8 A9 A10 A11A12 A13 A14 A15
p2 p2 p2 p2
p1
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 295
#define N 16shared [3] int A[N],*p1,*p2;shared int *p3
p1 = &A[5];p2 = p1 + 4;p3 = p1 + 3;
S
P
T0 T1 T2T3
A0 A3 A6 A9A1 A4 A7 A10A2 A5 A8 A11A12 A15A13A14
p1 p1 p1 p1p2 p2 p2 p2p3 p3 p3 p3
p1
p2
p3
Variables y punteros
Laboratorio de ParalelismoIF - EHU
UPC 305
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.
Movimiento de datos
Laboratorio de ParalelismoIF - EHU
UPC 315
• 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
Movimiento de datos
Laboratorio de ParalelismoIF - EHU
UPC 325
Funciones UPC para la gestión dinámica de la memoria
• 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.
• Recordad: cada thread tiene una zona de memoria privada, y una zona de memoria compartida accesible por todos los threads.
Memoria dinámica
Laboratorio de ParalelismoIF - EHU
UPC 335
• 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.
Memoria dinámica
Laboratorio de ParalelismoIF - EHU
UPC 345
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.
Memoria dinámica
• Funciones globales (reservan memoria en todos los threads):
Laboratorio de ParalelismoIF - EHU
UPC 355
• Ejemplos:shared [N] int *ptr;ptr = (shared [N] int*) upc_all_alloc(THREADS,N*sizeof(int));
shared [N] int *ptr;ptr = (shared [N] int*) upc_global_alloc(THREADS,N*sizeof(int));
ptr ptr ptr
S
P
ptr ptr ptr
S
P
Memoria dinámica
Laboratorio de ParalelismoIF - EHU
UPC 365
• Función local (reserva memoria sólo en la parte shared del thread que ejecuta la función):
• Para liberar memoria:
> void upc_free (shared void *ptr);
> shared void *upc_alloc (nbytes);
Devuelve un puntero al bloque de datos shared de la memoria afín.
Memoria dinámica
Laboratorio de ParalelismoIF - EHU
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.
Índice
Laboratorio de ParalelismoIF - EHU
UPC 385
UPC sólo dispone de un constructor para repartir tareas; en concreto, las iteraciones de un bucle for, de forma estática.
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.
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).
Reparto de tareas (work sharing)
Laboratorio de ParalelismoIF - EHU
UPC 395
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).
Reparto de tareas
Laboratorio de ParalelismoIF - EHU
UPC 405
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;
Reparto de tareas
Laboratorio de ParalelismoIF - EHU
UPC 415
upc_forall(i=0; i<N; i++; i*THREADS/N) A[i] = A[i] + 1;
Ahora el reparto de las iteraciones es consecutivo.
La iteración i la ejecutará el thread que tenga afinidad con A[i], es decir el que tenga la variable en “su” memoria.
upc_forall(i=0; i<N; i++; &A[i]) A[i] = A[i] + 1;
Reparto de tareas
Ejemplos:
Laboratorio de ParalelismoIF - EHU
UPC 425
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.
Reparto de tareas
Laboratorio de ParalelismoIF - EHU
UPC 435
Ejemplo
#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];}
reparto estático entrelazado 1
accesos i locales
Reparto de tareas
A se reparte por filas
1 elemento de B y de X por thread (round robin)
Laboratorio de ParalelismoIF - EHU
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.
Índice
Laboratorio de ParalelismoIF - EHU
UPC 455
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.
Sincronización y consistencia
Laboratorio de ParalelismoIF - EHU
UPC 465
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)
Sincronización y consistencia
Laboratorio de ParalelismoIF - EHU
UPC 475
Funciones de sincronización que ofrece UPC:
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);
Sincronización y consistencia
2 Cerrojos
Laboratorio de ParalelismoIF - EHU
UPC 485
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
Sincronización y consistencia
Laboratorio de ParalelismoIF - EHU
UPC 495
Modelo de consistencia. Recordad:
> orden de los accesos a memoria> cuándo se ven los cambios de las variables compartidasUPC 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.
Sincronización y consistencia
Laboratorio de ParalelismoIF - EHU
UPC 505
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;
Sincronización y consistencia
Laboratorio de ParalelismoIF - EHU
UPC 515
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;
Recuerda: el modelo de consistencia estricto puede tener consecuencias importantes en el rendimiento del sistema.
Todos los accesos a variables shared previos han terminado antes de proceder con accesos posteriores.
Sincronización y consistencia
Laboratorio de ParalelismoIF - EHU
UPC 525
#include <upc_relaxed.h>shared int A, flag;
... flag = 0; if (MYTHREAD==0) { A = ...; flag = 1; } else { while(flag==0) { }; ... = A; }...
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; } }...
strict shared int A, flag;
#pragma upc strictupc_fence;
upc_fence;
Sincronización y consistencia
Laboratorio de ParalelismoIF - EHU
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.
Índice
Laboratorio de ParalelismoIF - EHU
UPC 545
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).
Operaciones colectivas
Laboratorio de ParalelismoIF - EHU
UPC 555
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 bytessync_model: variable de tipo upc_flag_t, para
indicar cómo se sincronizan los procesos.
Operaciones colectivas
Laboratorio de ParalelismoIF - EHU
UPC 565Operaciones 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 threadMY: sólo se leen/escriben datos afines a quienes ya han
llegadoALL: esperamos a todos para empezar / acabar
Laboratorio de ParalelismoIF - EHU
UPC 575
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 repartesync_model: como en el caso anterior
Operaciones colectivas
Laboratorio de ParalelismoIF - EHU
UPC 585
3 GatherRecoge 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).
Operaciones colectivas
Laboratorio de ParalelismoIF - EHU
UPC 595
4 ExchangeEfectúa una transposición de bloques de datos entre todos los threads.
> upc_all_exchange(*dest,*orig,tam,sync_model)
5 PermuteEfectúa una permutación de bloques de datos entre los threads.
> upc_all_permute(*dest,*orig,*perm,tam, sync_model)
Operaciones colectivas
T0: D0 D1 D2T1: D3 D4 D5T2: D6 D7 D8
T0: D0 D3 D6T1: D1 D4 D7T2: D2 D5 D8
Laboratorio de ParalelismoIF - EHU
UPC 605
6 ReduceOperación (conmutativa) típica de reducción de datos.
> upc_all_reduceT(...)
7 Otras
> upc_all_prefix_reduce(...)> upc_all_sort(...)
Operaciones colectivas
Laboratorio de ParalelismoIF - EHU
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.
Índice
Laboratorio de ParalelismoIF - EHU
UPC 625
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.
Conclusiones
Laboratorio de ParalelismoIF - EHU
UPC 635
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 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.
Rendimiento
Laboratorio de ParalelismoIF - EHU
UPC 645
Para obtener un buen rendimiento con UPC
-- 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).
-- Compilar con la opción –opt, para aplicar las optimizaciones típicas del compilador (sio no están implementadas las optimizaciones habituales –O).
Rendimiento
Laboratorio de ParalelismoIF - EHU
UPC 655
OpenMP MPI UPC
Modelo de programación
memoria compartida
paso de mensajes
memoria compartida distribuida
Lenguajes C / Fortran C / Fortran C
Expresión del paralelismo
directivas y funciones
librería de funciones
extensión de C, funciones
Arquitecturas SMP MIMD + SMP MIMD + SMP
Topologías virtuales --- sí ---
Resumen final (i)
Laboratorio de ParalelismoIF - EHU
UPC 665
Grado de paralelismo
variablev. ent. / func.
fijompirun –np
fijocomp. / ejec.
Paralelismo anidado sí no no
Aprovechamiento de la localidad
datos---
difícilreparto de
datos explícitosí (afinidad)
Operaciones colectivas
---
BroadcastScatter/Gather
Reduction-
BroadcastScatter/Gather
Reduction-
OpenMP MPI UPC
Resumen final (ii)
Laboratorio de ParalelismoIF - EHU
UPC 675
Planificación (work sharing)
sí estát. / dinám.
costosa sí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
OpenMP MPI UPC
Resumen final (iii)
Laboratorio de ParalelismoIF - EHU
Páginas web de UPC (con toda la información)
upc.lbl.gov (Berkeley Univ.)
upc.gwu.edu (George Washington Univ.)
www.intrepid.com/upc (gcc UPC)
Libro
UPC: Distributed Shared Memory programming
T. El-Ghazawi, W. Carlson, T. Sterling, K. Yelick
J. Wiley, 2005.
Referencias
Laboratorio de ParalelismoIF - EHU
Javier Muguerza&
Agustin Arruabarrena
Konputagailuen Arkitektura eta TeknologiaArquitectura y Tecnología de Computadores
Informatika FakultateaEuskal Herriko Unibertsitatea
EHU - KAT
2012ko maiatza
Títulos de crédito
paralelismokolaborategialaboratoriodeparalelismo