Que es computo

paralelo?

Cmputo serial

Cmputo paralelo

CPU vs GPU

Diferencia entre CPU y GPU

CPU

GPU

OpenCL

OpenCL (Open Computing Language)

OpenCL es el primer estndar libre y abierto para la
programacin paralela de sistemas heterogeneos

Modelo de Ejecucin de OpenCL

Las aplicaciones de OpenCL trabajan en un host que
enva tareas a los dispositivos de computo.
Contexto: El ambiente donde los work-items se ejecutan.
Estos son los dispositivos, memoria y colas de comandos.

Programa: Coleccin de Kernels y funciones

Kernel: Codigo para un work-item.

Work Item: La unidad bsica de trabajo en OpenCL

(anlogo a hilos o procesos).
Command Queues: Ejecucin en orden o fuera de orden.

Work-items

Los Kernels son ejecutados bajo un dominio global de Work-items

Los Work-items se agrupan en workgroups locales

Los Work-items se pueden configurar de a cuerdo a las necesidades del

algoritmo.

Dimensiones Globales: 1024x1024

Dimensiones Locales: 128x128

Modelo de Memoria de OpenCL

El manejo de Memoria es explcito

Kernels

El conjunto de uno o mas kernels se llama programa.

Compilacin online y offline.

OpenCL C Language (estndar C99 con algunos

agregados).
Cada Work-Item ejecuta una instancia del kernel.

OpenCL en resumen

Memoria
En OpenCL, grandes objetos de memoria principal del host o del dispositivo
(GPU, Acelerador, etc) necesita un tratamiento especial, la primera razn es
porque esta memoria es relativamente lenta, la segunda es porque las copias
a travs del PCI-Express toman tiempo.

Memoria
clCreateBuffer ( y otras funciones equivalentes )
especifican una serie de banderas que definen el
comportamiento y utilizacin de los buffers de
memoria.
Dichas banderas se pueden clasificar en 3 clases.

Banderas de acceso en el dispositivo

CL_MEM_READ_ONLY: el kernel solo puede leer la
memoria, la escritura est prohibida.
CL_MEM_WRITE_ONLY: el kernel solo puede escribir
en la memoria, la lectura est prohibida.
CL_MEM_READ_WRITE: el kernel puede leer y escribir
en la memoria.

Banderas de acceso en el host

CL_MEM_HOST_WRITE_ONLY: El host solo puede leer la
memoria.
CL_MEM_HOST_READ_ONLY: El host solo puede escribir en
la memoria.
CL_MEM_HOST_NO_ACCESS: Se crea una regin de
memoria en el host, compartida entre dos o ms kernels, en esta
regin no se permite lectura o escritura por parte del host.
Estas banderas no se pueden combinar con:
CL_MEM_WRITE_ONLY | CL_MEM_COPY_HOST_READ_ONLY
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_WRITE_ONLY

Banderas de memoria en el host

<vacio> : Comportamiento normal, escrituras y lecturas son
explicitas (de dispositivo a host y viceversa).
CL_MEM_COPY_HOST_PTR: Al momento de crear el buffer, se
copian los datos de memoria del host al dispositivo.
CL_MEM_ALLOC_HOST_PTR: Se reserva un espacio de
memoria para el dispositivo (en RAM o GPU) al que el host tiene
acceso.
CL_MEM_USE_HOST_PTR: El buffer de memoria en el
dispositivo es ligado a una regin de memoria en el host.
Estas banderas no se pueden combinar con CL_MEM_COPY_HOST_NO_ACCESS

Pinned Memory
Este tipo de memoria es especial, una regin de memoria en el
host se liga con una regin de memoria en el dispositivo, durante
las transferencias se le dan accesos exclusivos a cada parte
(Host y dispositivo) para leer o escribir a travs de DMA (Direct
memory access), resultando en tiempos de transferencia
menores.
En OpenCL se habilita utilizando las banderas
CL_MEM_USE_HOST_PTR y CL_MEM_ALLOC_HOST_PTR
junto con las funciones:
clEnqueueMapBuffer
clEnqueueUnmapMemObject

clEnqueueMapBuffer y
clEnqueueUnmapMemObject
Estas funciones hacen lock y un unlock en regiones de memoria ligadas.
CL_MAP_WRITE: Se puede escribir en el buffer, se transferirn datos al
dispositivo por DMA.
CL_MAP_READ: Se puede leer el buffer, se transferirn datos desde el
dispositivo por DMA.
CL_MAP_READ | CL_MAP_WRITE: Habr transferencias durante la
lectura y escritura de la memoria.

Kernel y Work-Items

Work-Items

Work-items son la unidad bsica de trabajo en OpenCL, estos se

ejecutan en grupos y de manera paralela.
Los Work-Items dentro de un grupo pueden compartir datos y
sincronizarse.

Work-Items
work_dim indica el numero de
ndices que identifican a cada
Work-Item.
global_work_size es el
nmero total de Work-Items
por cada dimensin.
local_work_size es el nmero
de Work-Items por cada
dimensin de cada WorkGroup.

Kernel
El Kernel es la funcin principal que se ejecutara en paralelo, cada WorkItem ejecuta una copia del kernel.
El modelo de programacin paralela de
datos en OpenCL es de dos tipos:
Explcita: El programador especifica el numero
de Work-Items que ejecutarn el kernel y define
la divisin de Work-Items entre Work-Groups.
Implcita: El programador especifica el numero
de Work-Items que ejecutarn el kernel, y
OpenCL definir la divisin de Work-Items entre
Work-Groups.

Kernel: Definicin
void VectorAdd(float *vector1, float *vector2, float *total)
{
for(int index = 0; index < VECTOR_SIZE; index++)
total[index] = vector1[index] + vector2[index];
}

Definicin serial

__kernel void VectorAdd(__global float *vector1, __global float *vector2, __global float *total)
{
uint index = get_global_id(0);
Definicin paralela
total[index] = vector1[index] + vector2[index];
}

Kernel: Definicin de memoria

En OpenCL se debe especificar la regin de memoria donde se alojan
los datos.
__private Memoria exclusiva de cada Work-Item, no es accesible a
otros Work-Items.
__local Memoria de cache accesible para todos los Work-Items
dentro de un Work-Group, no es accesible para otros Work-Items
__constant Memoria de solo lectura, es accesible para todos los
Work-Items
__global Memoria general de lectura y escritura, es accesible para
todos los Work-Items

Kernel: Tipos de Datos

Escalares
char , uchar, short, ushort, int, uint, long, ulong, float
bool, intptr_t, ptrdiff_t, size_t, uintptr_t, void, half
Imgenes
image2d_t, image3d_t, sampler_t
Vectores
Tamaos de Vector 2, 4, 8, y 16 (char2, ushort4, int8, float16, double2, )
Operaciones Vectorizadas
Funciones nativas

Kernel: Vectores

Imgenes

Imgenes
OpenCL posee una serie de funciones primitivas para la manipulacin de
imgenes, la utilizacin de imgenes en lugar de buffers de datos puede ser
beneficioso en ciertos casos.
Las imgenes se guardan en el cache de texturas del dispositivo (si este lo
soporta).
Este cache de textura permite accesos ms rpidos a los bytes.
Hasta el estndar 1.2, las imgenes solo pueden ser de solo lectura o solo
escritura.
La creacin de estos buffers es diferente del lado del host
El acceso a los datos de la imagen es diferente del lado del Kernel.

Imgenes (Host)
La creacin de buffers de imagen desde el host, se hace a travs de las
funciones:
clCreateImage2D: crea un buffer de imagen de dos dimensiones.
clCreateImage3D: crea un buffer de imagen de tres dimensiones.
clCreateImage: crea un buffer de imagen de cualquier tipo.
Estas funciones son anlogas a clCreateBuffer.
clCreateImage2D y clCreateImage3D son funciones eliminadas desde el
estndar
1.2 y reemplazadas con clCreateImage.

Imgenes (Host)

La escritura y lectura de imgenes es anloga a la escritura y lectura de buffers:

clEnqueueWriteImage: Escribe datos a una imagen desde un apuntador en el
host.
clEnqueueReadImage: Lee los datos de una imagen en el dispositivo para
escribirlos en un apuntador en el host.
Estas funciones son parecidas a clEnqueueWriteBuffer y clEnqueueReadBuffer.

Imgenes (Kernel)
Los tipos de imgen que son soportados por el kernel.
image2d_t: Una imgen 2D.
image3d_t: Una imgen 3D.
image2d_array_t: Un arreglo de imgenes 2D.
image1d_t: Una imagen 1D
image1d_buffer_t: Una imagen 1D creada desde buffer
image1d_array_t: Un arreglo de imgenes de 1D.
Estos tipos van precedidos por los Calificadores de acceso:
__read_only: Solo lectura.
__write_only: Solo escritura.

Imgenes: Lectura y escritura

El acceso a los bytes de las imgenes es a travs de las funciones:
read_image: Regresa un pixel en una coordenada establecida.
write_image: Escribe un pixel en una coordenada establecida.
Adems, read_image requiere de un sampler_t que define como se van a leer
los pixeles.
normalized coords
address mode
filter mode

Work-groups y Sincronizacin

Work-groups y sincronizacin
Un aspecto esencial del modelo de ejecucin de OpenCL es la definicin de
un ID nico global y una serie de ID nicos locales para los Work-Items.
Estos IDs nos permiten identificar, donde reside cada instancia paralela del
Kernel en el espacio de los ndices.

Work-groups y sincronizacin
Los work-items se ejecutan en grupos, dentro de estos grupos, los work-items
comparten algunos recursos y pueden sincronizarse entre ellos.
La sincronizacin viene a travs de las funciones mem_fence y barrier.
mem_fence: Todos los work-items dentro del work-group deben terminar su
lectura o escritura a memoria al pasar esta funcin, recibe como parmetro,
cualquiera de estas dos constantes o combinacin :
CLK_LOCAL_MEM_FENCE, CLK_GLOBAL_MEM_FENCE.
barrier: Cada work-items dentro del work-group debe esperar en esta
funcin hasta que el resto de los work-items lleguen, recibe como parmetro
cualquiera de estas dos constantes o combinacin:
CLK_LOCAL_MEM_FENCE, CLK_GLOBAL_MEM_FENCE

Work-groups: Memoria Local

La memoria local es un cache de latencia muy baja, este cache esta
repartido entre todas las unidades de computo y es accesible por todos
los work-items dentro de un work-group.
Esta memoria es utilizada para compartir datos entre work-items y
acelerar algunos procesamientos.
Por ser una memoria muy rapida, el tamao de este cache es muy
pequeo.
En el Kernel, esta memoria se declara con el calificador __local

MinMax
El algoritmo de bsqueda del menor y mayor nmero en un vector, es un
algoritmo iterativo que no se puede paralelizar con la simple tcnica de un
dato por work-item.

MinMax: paralelo

Dividir el vector en N sub-vectores de tamao especfico.

Asignar un sub-vector a cada work-group.
Cada work-item copiara un dato del sub-vector a un buffer local.
El work-item 0 buscar el mnimo y mximo en el buffer local de
manera iterativa.
El resultado parcial se guardara en una ndice especifico de el vector
de resultados, el work-item 0 de cada work-group incrementa
atmicamente este ndice.
Cuando todos los work-items 0 hallan terminado de encontrar el
mnimo y mximo, un ltimo work-item buscara el mnimo y mximo
final dentro del vector de resultados.

Interoperabilidad entre
OpenCL y OpenGL

Interoperabilidad
OpenCL y OpenGL son dos API con una eficiente interoperabilidad. Por
un lado OpenCL esta diseado para computo paralelo para diferentes
plataformas, mientras que OpenGL es una popular API grfica.
Esta interoperabilidad brinda algunas ventajas:
La programacin de kernels en OpenCL es mas sencillo que utilizar el
lenguaje de sombreado de OpenGL (GLSL).
El cmputo de kernels es asncrono al sistema de render de OpenGL.
OpenCL funciona en otros dispositivos adems de las GPUs.
No hay necesidad de transferencias por el PCIe.

Interoperabilidad
Esta interoperabilidad se logra creando un contexto compartido entre
OpenCL y OpenGL.

Interoperabilidad
Habilitar esta interoperabilidad se hace a travs de la funcin clCreateContext. El
primer parmetro de la funcin define las propiedades del contexto.
Estas propiedades dependen del sistema operativo:
A travs de un Contexto KHR en Linux y Windows:
Linux
glXGetCurrentContext
glXGetCurrentDisplay
Windows
wglGetCurrentContext
wglGetCurrentDC
Y a travs de un Sharegroup en Mac:

CGLGetCurrentContext
CGLGetShareGroup

Interoperabilidad: Manipulacin de Texturas

OpenCL crea un buffer de memoria desde una Textura OpenGL ya

existente.
Este buffer se crea con la funcin clCreateFromGLTexture.
Las Texturas OpenGL son interpretadas como imgenes en OpenCL, se
manipulan en el kernel con las funciones write_image, read_image.

Manipulacin de Texturas, pasos

Crear la textura OpenGL con la funcin glTexImage2D (debe recibir un
buffer NULL).
Crear el buffer de memoria en OpenCL con clCreateFromGLTexture,
esta funcin recibe el ID de la textura OpenGL.
Antes de dibujar la escena:
Bloquear la textura con clEnqueueAcquireGLObjects para que
OpenGL no interfiera.
Ejecutar el kernel que manipula la textura.
Liberar la textura con clEnqueueReleaseGLObjects para que
OpenGL pueda dibujarla.

Interoperabilidad: Manipulacin de Buffers

OpenCL es capaz de acceder a otros tipos de buffer de OpenGL, tales

como Vertices, Normales, Colores, Elementos, etc.
Estos buffers, a diferencia de las texturas, se pueden utilizar como lectura
y escritura a la vez.
Las variables de acceso a estos buffers de OpenGL se hacen a travez de
la funcin clCreateFromGLBuffer.

Manipulacin de Buffer, pasos

Crear los buffers OpenGL con la funcin glGenBuffers
Crear el buffer de memoria en OpenCL con clCreateFromGLBuffer,
esta funcin recibe el ID del buffer OpenGL.
Antes de dibujar la escena:
Bloquear los buffers con clEnqueueAcquireGLObjects para que
OpenGL no interfiera.
Ejecutar el kernel que manipula los buffers.
Liberar los buffers con clEnqueueReleaseGLObjects para que
OpenGL pueda dibujarlos.