GPGPU Introducción Programación Paralela

Computación de Propósito General en
Unidades de Procesamiento Gráfico
(GPGPU)

E. Dufrechou, P. Ezzatti y M. Pedemonte
Dufrechou,

Clase 3 – Programación paralela GPGPU

Clases 3
Programación paralela


Contenido

• Conceptos básicos de programación paralela
• Herramientas para GPU (básico)
– Compilación
– Hello world


1

Conceptos básicos de
Programación Paralela


Conceptos Básicos de Programación Paralela

• Múltiples unidades de cómputo trabajando en forma
coordinada
• Comunicación
• Sincronización
• División
• De tareas
• De datos



• Paralelismo de
• Memoria compartida (multi-core)
• Memoria distribuida (cluster)
• Contexto
• Homogéneo
• Heterogéneo
• Balance de carga


2


En este caso:

• Muchas unidades de cómputo trabajando en forma
coordinada.

• División de datos.

• Paralelismo “similar” a paralelismo a memoria compartida
(multi-core).

• Unidades de procesamiento homogéneas.



En los ejemplos que se verán a continuación:

• Se utilizará una sintaxis inspirada en la de Matlab.

• El código escrito en color negro ejecuta en forma secuencial.

• El código escrito en color azul indica palabras reservadas que son
directivas para el manejo de paralelismo.

• El código escrito en color rojo indica el punto de ramificación del
paralelismo.

• El código escrito en color verde es el código que es ejecutado en forma
paralela por cada una de las unidades de procesamiento.


Ejemplo 0:

• Se tiene una matriz con
4 columnas y se quiere
obtener la suma por
columnas de la matriz.
• Se dispone de una única
unidad de
procesamiento.


3

Ejemplo 0:

Res = zeros(1,4)
[m,n] = size(Mat)
For j = 1:4
For i = 1 : m
Res(j) = Res(j) +
Mat(i,j)


Ejemplo 1:

• Se tiene una matriz con
4 columnas y se quiere
obtener la suma por
columnas de la matriz.
• Se dispone de cuatro
unidades de
procesamiento.


Ejemplo 1:
Res = zeros(1,4)
[m,n] = size(Mat)
begin_parallel(4)
For j = 1:4
For i = 1 : m
Res(j) = Res(j) + Mat(i,j)
end_parallel


4

Ejemplo 2:

• Se tiene una matriz con 400 columnas y se quiere obtener la
suma por columnas de la matriz.
• Se dispone de cuatro unidades de procesamiento.


Ejemplo 2:

Res = zeros(1,400)
[m,n] = size(Mat)
begin_parallel(4)
For j = 1:400
For i = 1 : m
end_parallel


Ejemplo 3:

• Se sabe que el trabajo para realizar la suma de una columna es
irregular (por ejemplo, sumar 0 es menos costoso
computacionalmente que sumar otro número).


5


Distribución de datos

Distribución por bloque Distribución cíclica


Ejemplo 3:

• Es posible achicar el tamaño de los bloques.
• Por ejemplo: de 100 columnas pasar a 10 columnas por bloque.

Res = zeros(1,400)
[m,n] = size(Mat)
begin_parallel(40)
For j = 1:400
For i = 1 : m
end_parallel



Ejemplo 4:

• Se sabe que el trabajo para realizar la suma de una columna es
irregular (por ejemplo, sumar 0 es menos costoso
computacionalmente que sumar otro número).
• En este caso, además se quiere obtener la suma parcial por
unidad de procesamiento.


6


Ejemplo 4:


Ejemplo 4:
Res = zeros(1,400)
Res2 = zeros(1,4)
[m,n] = size(Mat)
begin_parallel(40)
For j = 1:400
private idP = myId()
For i = 1 : m
Res2(idP) = Res2(idP) + Res(j)
end_parallel



Ejemplo 5:

suma de todos los elementos de la matriz.


7


Solución 1
• Se suma por columna

• Luego se suma todo el vector intermedio



Solución 1

• Se suma por columna y luego se suma el vector intermedio.
Res = zeros(1,400)
[m,n] = size(Mat)
begin_parallel(4)
For j = 1:400
For i = 1 : m
end_parallel
For j = 1:400
Sum = Sum + Res(j)


Solución 2
• Se suma por columnas para cada unidad de procesamiento.

• Luego se suma el vector intermedio.


8

Solución 2
Res = zeros(1,4)
• Se suma por columnas [m,n] = size(Mat)
para cada unidad de begin_parallel(4)
procesamiento y luego For j = 1:400
se suma el vector private idP = myId ()
intermedio. For i = 1 : m
Res(idP) = Res(idP) +
Mat(i,j)
end_parallel
For j = 1:4
Sum = Sum + Res(j)



Solución 3
Res = zeros(1,4)
• Sumo por columna [m,n] = size(Mat)
y actualizo el begin_parallel(4)
resultado. For j = 1:400
private idP = myId ()
For i = 1 : m
• Concepto de
Res(idP) = Res(idP) + Mat(i,j)
reduce
end_parallel
begin_parallel(2)
For j = 1:4
Sum = Sum + Res(j)
end_parallel


Race condition:
Res = zeros(1,4)
- Los hilos compiten por
[m,n] = size(Mat)
el acceso a los
begin_parallel(4)
registros.
For j = 1:400
- Pueden haber distintos
ordenes de ejecución.
For i = 1 : m
Res(idP) = Res(idP) +Mat(i,j) - Distinto orden de
end_parallel
ejecución produce
resultados
begin_parallel(2)
diferentes!!!
For j = 1:4
Sum = Sum + Res(j)
- Este problema también
aparece en circuitos
end_parallel
electrónicos, base de
datos, etc.

9


Reduce:
[m,n] = size(Mat)
- Generalmente están
begin_parallel(4) disponibles diversas
private Res operaciones:
For j = 1:400
• +
%private idP = myId ()
• *
For i = 1 : m
Res = Res + Mat(i,j) • min
end_parallel (reduce(+,Res)) • max



Consideremos el
siguiente código: Res = zeros(1,11)
aux = 11
• Hay problemas por el begin_parallel(400)
acceso concurrente a For j = 1:400
la variable aux. private idP = myId ()
if (aux == 1)
aux = aux + 10
else
aux = aux - 1
end
Res(aux) = Res(aux) +Mat(j)
end_parallel



Diferentes formas de
resolverlo: Res = zeros(1,11)
aux = 11
• Semáforos begin_parallel(400)
• Zonas mutuo For j = 1:400
excluidas private idP = myId ()
• Operaciones atómicas if (aux == 1)
aux = aux + 10
else
aux = aux - 1
end
Res(aux) = Res(aux) +Mat(i,j)
end_parallel


10


Res = zeros(1,11)
Con zonas mutuo
begin_parallel(400)
excluidas
For j = 1:400
begin_mutex()
Solo un “hilo de if (aux == 1)
ejecución” entra en la aux = aux + 10
zona. else
aux = aux - 1
end
Res(aux) = Res(aux) +Mat(aux,j)
end_mutex()
end_parallel


Res = zeros(1,11)
begin_parallel(400)
Con zonas mutuo private aux2
excluidas y For j = 1:400
operaciones atómicas begin_mutex()
if (aux == 1)
aux = aux + 10
else
aux = aux - 1
end
aux2=aux
end_mutex()
begin_atomic()
Res(aux2) = Res(aux2) +Mat(aux2,j)
end_atomic()
end_parallel


Diferentes caminos dependiendo del thread (similar a zonas
mutuo excluidas)
begin_parallel(400)
For j = 1:400
if (mod(idP,2) == 0)
Mat(j) = Mat(j) + 4
else
Mat(j) = Mat(j) + 2
end
end_parallel
• Estrategia comúnmente utilizada para implementar el
modelo de paralelismo Maestro-Esclavo: if soyMaestro()

11


Conceptos vistos

• Paralelismo
• Estrategias de scheduling y balance de carga
• Distribución de datos
• Utilizar información del thread
• Reducciones
• Race conditions
• Operaciones atómicas



Es conveniente tener en cuenta:

• La importancia del scheduling, distribución de datos y
control de sincronizaciones para un buen desempeño.

• Si bien parece obvio, además de buen desempeño es
necesario correctitud. Sin embargo, esto es más
complejo de comprobar que en programas secuenciales.


Herramientas para GPU


12

Compilación
C/C++ CUDA
Application

NVCC CPU Code

PTX Code

PTX to Target
Compiler

G80 … GPU

Target code

Compilación

Compilación:

nvcc algo.cu –o algo
nvcc –c algo.cu

Salidas:
• Código C code (código del host)
• Se compila con una herramienta tradicional
(automáticamente).
• Código PTX
• Directamente código objeto.
• Para interpretar en tiempo de ejecución.

Compilación

Enlazado

Los códigos CUDA requieren dos librerias dinámicas:
• The CUDA runtime library (cudart)
#include <cuda_runtime_api.h>
• The CUDA core library (cuda)
#include <cuda.h>


13

Hello World

#include <stdio.h>

__global__ void kernel() {
}

int main( void ) {
kernel<<<1,1>>>();
printf( "Hello, World!n" );
return 0;
}


14

GPGPU Introducción Programación Paralela

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (12)

Ähnlich wie GPGPU Introducción Programación Paralela

Ähnlich wie GPGPU Introducción Programación Paralela (20)

Mehr von Xavier Davias

Mehr von Xavier Davias (20)

GPGPU Introducción Programación Paralela