. 5 . O TRAS A LTERNATIVAS: U nified P arallel C (resumen ).

Laboratorio de ParalelismoIF - EHU

. 5 .OTRAS ALTERNATIVAS:

Unified Parallel C (resumen).


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


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


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


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


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


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


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


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


UPC 105


T1 T2 T3 T4

privada

compartida

Introducción


UPC 115


• 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


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


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


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


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


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


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).



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.



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



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;



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?



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.



UPC 235

Ejemplos de punteros

private

shared

P4P3

Thread i

P1 P1 P1P2 P2 P2



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



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



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.



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



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



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



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


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


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


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


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):


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


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



datos. Memoria dinámica.

3. Reparto de tareas (work sharing).

4. Sincronización y consistencia.5. Librería de operaciones colectivas.6. Conclusiones.

Índice


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)


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


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


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:


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


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)



datos. Memoria dinámica.3. Reparto de tareas (work sharing).

4. Sincronización y consistencia.

5. Librería de operaciones colectivas.6. Conclusiones.

Índice


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


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)



UPC 475


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);


2 Cerrojos


UPC 485


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



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.



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;



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.



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;




datos. Memoria dinámica.3. Reparto de tareas (work sharing).4. Sincronización y consistencia.

5. Librería de operaciones colectivas.

6. Conclusiones.

Índice


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


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.



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


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



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).



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)


T0: D0 D1 D2T1: D3 D4 D5T2: D6 D7 D8

T0: D0 D3 D6T1: D1 D4 D7T2: D2 D5 D8


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(...)




datos. Memoria dinámica.3. Reparto de tareas (work sharing).4. Sincronización y consistencia.5. Librería de operaciones colectivas.

6. Conclusiones.

Índice


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


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


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


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)


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)


---

BroadcastScatter/Gather

Reduction-

BroadcastScatter/Gather

Reduction-

OpenMP MPI UPC

Resumen final (ii)


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)


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


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

. 5 . O TRAS A LTERNATIVAS: U nified P arallel C (resumen ).

Documents

Transcript of . 5 . O TRAS A LTERNATIVAS: U nified P arallel C (resumen ).