1 Brevisimo Tutorial de OpenMP

Brevsimo tutorial de OpenMP
MSc Miguel Vargas-Flix

miguelvargas@cimat.mx
http://www.cimat.mx/~miguelvargas
17/08/11
1/37
Contenido
Contenido
Cmputo en paralelo
Operaciones matemticas en paralelo
Evolucin de los procesadores de propsito general
El cache
El esquema OpenMP
Prdida de eficiencia con el aumento de procesadores
Post data: Optimizar el cdigo compilado
Preguntas?
Para saber ms...
17/08/11
2/37
Nmero de instrucciones por segundo

2E+10
1E+10
1970
3E+10
1975
1985
1990
17/08/11
1995
6E+10
5E+10
4E+10
2000
8E+10
2005
Intel Core i7
AMD Phenom II X4 (76G ips)
(43G ips)
Intel Core 2
(49G ips)
7E+10
PlayStation 3 Cell
(10G ips)
AMD Athlon XP (5.9G ips)

Intel Pentium IV (9.7G ips)
Intel Pentium III

(1.4G ips)
Motorola 68040
(44M ips)
Intel 80x486
(54M ips)
Motorola 68060
(88M ips)
Intel Pentium Pro
(541M ips)
0E+0
Intel 80x386
(11M ips)
1980
Intel 80x286
(4M ips)
Motorola 68000
(1M ips)
Intel 8080
(500K ips)
Intel 4004
(92K ips)
Cmputo en paralelo
Cmputo en paralelo
La evolucin de la velocidad de los procesadores
2010
procesadores
multi-core
3/37
Cmputo en paralelo
Tenemos ahora que desarrollar nuevos esquemas para disear algoritmos
Algoritmo
en
paralelo
Algoritmo
en
serie
La meta es reducir tiempo necesario para realizar una secuencia de instrucciones.

La buena noticia: Hacer programas en paralelo con OpenMP es muy sencillo.
La mala noticia: Hacer programas en paralelo eficientes requiere un esfuerzo extra.
17/08/11
4/37

Fcilmente paralelizables
Esto significa que pueden separarse en varias sub-operaciones que puede realizarse de forma
independiente. Por ejemplo, el la suma de dos vectores x, y para producir otro vector c,
ci = x i y i, i=1, , N.
En este caso las N sumas pueden realizarse simultneamente, asignando una a cada procesador.
Lo que hay que resaltar es que no hay dependencia entre los diferentes pares de datos, tenemos
entonces el paralelismo ms eficiente.
No tan fciles de paralelizar

Por ejemplo el producto punto x , y
N
a= x i y i,
i=1
donde a es un escalar, una primera aproximacin sera verlo como una secuencia de sumas de
productos que requieren irse acumulando, al verlo as no es una operacin paralelizable.
17/08/11
5/37
Sin embargo, podemos reorganizar el proceso como se muestra en la figura:

x1 y1
x2 y2
x3 y3
a= x i y i
x4 y4
x5 y 5
x6 y6
x7 y7
x8 y8
x9 y9
...
xn yn
...
i=1
...
+
a
En este caso se tiene una paralelizacin eficiente de la multiplicacin de las entradas de los
vectores, despus se va reduciendo la eficiencia. Muchos algoritmos seriales requieren, para ser
paralelizados, de re-ordenar las operaciones con una estrategia de divide y vencers, como en
el caso del producto punto.
17/08/11
6/37
Usualmente se tendrn memos procesadores que el tamao del vector, por lo que se asignan
varias operaciones de un grupo a cada procesador, las cuales se ejecutarn en secuencia, lo que
limita la eficiencia del paralelismo.
x1 y1
N
a= x i y i
x2 y 2
x3 y3
x4 y4
x5 y5
x6 y6
x7 y7
+
x 8 y8
x9 y9
...
xn yn
...
i=1
+
a
17/08/11
7/37

Hace unos 30+ aos
Single-core computer
Running program
Heap
Processor
Bus
Bus
RAM
Stack
Code
Data
Desde un punto de vista fsico muy simplificado, la computadora contiene un procesador (CPU)
que accesa a la memoria (RAM) a travs de un bus de datos/direcciones.
La velocidad de los procesadores y la memoria (RAM) era equivalente.
Desde el punto de vista de la ejecucin de un programa, la memoria est dividida en Heap (o
montculo), Stack (pila) donde se almacenan las variables declaradas dentro de una funcin y
Data (regin donde se almacenan las variables globales).
17/08/11
8/37
Hace unos 20+ aos

Single-core computer
Running program
Processor
Cache
Heap
Bus
Bus
RAM
Stack
Data
Code
Thread
Stack
Thread
Stack
Thread
Stack
La velocidad de los procesadores es mayor que la de la memoria RAM. Se introduce en el

procesador una memoria intermedia o cache de alta velocidad. El tamao del cache suele ser de
1/1000 del tamao de la RAM.
Los programas ejecutan varios hilos o threads en un pseudo-paralelismo.
Cada thread es una secuencia de instrucciones que se ejecuta de forma independiente. Un
programa puede tener uno o ms threads.
Los threads comparten las regiones de memoria Heap y Data, y adems trabajan con un stack
independiente para cada uno.
17/08/11
9/37
El cache
El cache
La velocidad de operacin de los procesadores es mucho mayor que la velocidad de acceso de la
memoria RAM de las computadoras [Wulf95], esto es debido a que es muy costoso fabricar
memoria de alta velocidad.
Para solventar esta diferencia en velocidad, los procesadores modernos incluyen memoria cache,
en diferentes niveles (L1, L2 y en algunos casos L3). Estas memoria cache son de alta velocidad
aunque de menor capacidad que la memoria RAM del sistema. Su funcin es la de leer de forma
anticipada memoria RAM mientras el core est trabajando y modificar la informacin leida de
forma local. Cuando entra nueva informacin al cache la informacin ya procesada es
almacenada en la memoria RAM.
La siguiente tabla muestra los ciclos de reloj de CPU necesarios para accesar cada tipo de
memoria en un procesador Pentium M:
Acceso a
Registro CPU
L1
L2
Memoria RAM
Ciclos
1
~3
~ 14
~ 240
Eso de caches es ms eficiente cuando se leen o escriben localidades de memoria continuas

[Drep07].
17/08/11
10/37
El cache
Para trabajar eficientemente con el cache es necesario que los datos con los cual trabaja el
programa sean puestos de forma continua en la memoria RAM. Las variables deben ser
declaradas dentro de la funcin en la cual sern utilizados, as estas estarn almacenados en el
stack, lo cual facilitar que caigan en el cache L1 [Fog10].
#define S 2000
Heap
a[]
int i;
double* a = (double*)malloc(S*sizeof(double));
void funcion(void)
{
double b[S];
for (i = 0; i < S; ++i)
b[i] = i*2.0;
for (int j = 0; j < S; ++j) {
b[j] += a[j];
a[j] = 0;
}
Stack
b, b[], j
Data
i, a
}
El programa anterior accesa localidades de memoria distantes.
17/08/11
11/37
El cache
El cache lee la memora RAM en por lneas o bloques de N bytes contiguos (N ~ 64). Los
circutos del cache estn diseados para hacer esta lectura de forma mucho ms rpida que
haciendo lecturas a regiones no contiguas.
Una lnea de cache se accesa ms rpido si se la lee de forma secuencial hacia adelante (i++).
Leerlo en forma inversa es un poco ms lento (i--).
17/08/11
12/37
El cache
Nota usted la diferencia?

#include <stdio.h>
#include <stdio.h>
#define ROWS 10000000

#define COLS 200
#define ROWS 10000000

#define COLS 200
int main(void)
{
char* A = new char[ROWS*COLS];
int main(void)
{
char* A = new char[ROWS*COLS];
for (int j = 0; j < COLS; ++j)

{
for (int i = 0; i < ROWS; ++i)
{
A[i*COLS + j] = i + j;
}
}
for (int i = 0; i < ROWS; ++i)

{
for (int j = 0; j < COLS; ++j)
{
A[i*COLS + j] = i + j;
}
}
delete [] A;
delete [] A;
return 0;
return 0;
126.760s
6.757s
El cdigo de la izquierda tard 18.76 veces ms que el de la derecha!

17/08/11
13/37
El cache
Desde hace unos 12+ aos
L1
L1
Slo existe un canal de comunicacin (bus de

datos/direcciones) con la RAM.
Core 2
Core 3
L1
El principal cuello de botella es en el acceso a la RAM.
Processor
Core 1
Cache L2
Ahora cada thread se ejecuta en un core. Tenemos un Multi-core computer

paralelismo real.
Bus
Bus
RAM
Si dos cores tratan de leer de la RAM uno tendr que

Running program
esperar a que el otro termine.
Esto ser ms y mas notorio cuando el sistema tenga
ms procesadores.
Heap
17/08/11
Thread
Core 1
Stack
Para reducir sta latencia se le ha agregado otro nivel
de cache, llamado L2.
Code
Data
Thread
Core 2
Thread
Core 3
Stack
Stack
Stack
14/37
El cache
El cache con multi-core
Si un core trata de accesar un dato de memoria que ya

est en su cach se le llama cache-hit.
Core 2
Core 3
Cache L2
L1
Processor
Core 1
L1
Si un core trata de actualizar memoria de la cual existe

copia en el cache de otro core, entonces se crea un
cache-fault y es necesario que uno de los cores accese a
L2 o la RAM para sincronizarse. Esto es muy costo.
Multi-core computer
L1
El problema aumenta con del esquema de procesamiento

en paralelo con memoria compartida.
Bus
Bus
RAM
There is not free lunch
Mantener coherencia en la informacin cuando varios cores accesan la misma memoria RAM es
complejo. Los detalles se pueden consultar en [Drep07].
17/08/11
15/37
El cache
Estrategias para mantener a cada core accesando lo ms posible su

propio cache
Operar con variables en el stack.
No guardar variables en data.
Reducir el nmero de escrituras al heap, realizar operaciones en el stack y solo escribir el
resultado en el heap.
Trabajar cada core con bloques de memoria contiguos.
Hacer que core trabaje en localidades de memoria diferentes.
Funciones que se usan juntas deben almacenarse cerca (en .lib o .a, no en .dll o .so)
17/08/11
16/37
El cache
Hace unos 8+ aos

Las computadoras con ms de un procesador multi-core estn diseadas para que cada
procesador accese a un banco de memoria independiente de forma rpida (NUMA, non-uniform
memory access). Accesar al banco de memoria del otro procesador es ms lento. Ahora se
requieren de circutos que mantengan la coherencia del cache entre todos los cores.
Multi-processor computer
Core 6
Code
Thread
Core 1
Cache
coherence
RAM
Stack
Data
Thread
Core 2
Thread
Core 3
Thread
Core 4
RAM
Thread
Core 5
Thread
L1
Core 5
L1
L1
Processor 2
Core 4
Cache L2
L1
Core 3
Heap
Cache L2
Core 2
L1
L1
Processor 1
Core 1
Running program
Core 6
17/08/11
Stack
Stack
Stack
Stack
Stack
Stack
17/37
El esquema OpenMP
El esquema OpenMP
Sirve para paralelizar programas en C, C++ o Fortran en computadoras multi-core o
multi-thread.
Busca que escribir cdigo en paralelo sea sencillo.
Es un esquema de paralelizacin con memoria compartida (todos los procesadores accesan a la
misma memoria).
Su funcionamiento interno es con threads, en el caso de sistemas POSIX se utiliza la librera de
POSIX-Threads (libpthread).
Algunos compiladores que soportan este esquema:
GNU Compiler Collection GCC (versin >= 4.3.2)
Intel Compiler Suite (version >= 10.1)
Microsoft Visual Studio 2008 (Professional)
Microsoft Visual Studio 2008 (Express) + Windows SDK for Windows Server 2008
La lista completa: http://openmp.org/wp/openmp-compilers
17/08/11
18/37
El esquema OpenMP
Programacin en hilos (threads)

A la ejecucin de cada secuencia de instrucciones se le conoce como un hilo de procesamiento o
thread. Cada thread posee sus propios registros de control y su propio stack de datos, mientas
que comparte el uso de la memorias del montculo (heap) y data con los dems threads del
programa. En las computadoras multi-core logra la mejor eficiencia cuando cada CPU ejecuta
slo un thread.
Procesamiento
paralelo
Procesamiento
serial
Core 1
Core 2
Thread
inactivo
Core 3
Core 4
Thread
activo
Core n
Creacin de
los threads
Sincronizacin
17/08/11
19/37
El esquema OpenMP
Un programa simple con OpenMP

Comencemos con la paralelizacin de la suma de dos vectores:
void Suma(double* a, double* b, double* c, int size)
{
for (int i = 0; i < size; ++i)
{
c[i] = a[i] + b[i];
}
}
La paralelizacin sera...
17/08/11
20/37
El esquema OpenMP
...la paralelizacin sera:

{
#pragma omp parallel for
{
c[i] = a[i] + b[i];
}
}
Para compilar con GCC es necesario agregar:

gcc -o programa -fopenmp main.c
En Visual C++ hay una opcin en las preferencias del proyecto para activar OpenMP.
17/08/11
21/37
El esquema OpenMP
Cmo funciona?
Supongamos que size = 30, si la computadora tiene 3 procesadores, el cdigo se ejecutara como:
{
for (int i = 0; i < 10; ++i) for (int i = 10; i < 20; ++i) for (int i = 20; i < 30; ++i)
{
{
{
c[i] = a[i] + b[i];
c[i] = a[i] + b[i];
c[i] = a[i] + b[i];
}
}
}
}
Cmo se define el nmero de procesadores/threads a utilizar?

- Por default el nmero de threads es igual al nmero de cores en la computadora.
- Se puede establecer por medio de variables de ambiente
- Se puede definir en el cdigo en run-time.
17/08/11
22/37
El esquema OpenMP
Establecer nmero de threads con variables de ambiente

Se hace a travs de la variable de ambiente OMP_NUM_THREADS
En Linux/Unix (Bash):
export OMP_NUM_THREADS=3
programa
En Windows:
set OMP_NUM_THREADS=3
programa.exe
17/08/11
23/37
El esquema OpenMP
Establecer nmero de threads con cdigo

Es necesario incluir el header omp.h, el cual incluye varias funciones para el control de
threads.
#include <omp.h>
int threads = 3;
{
omp_set_num_threads(threads);
for (int i = 0; i < size; ++i) {
c[i] = a[i] + b[i];
}
}
17/08/11
24/37
El esquema OpenMP
Reducciones
El ejemplo que mostraremos es el producto punto:
double ProductoPunto(double* a, double* b, int size)
{
double c = 0;
c += a[i]*b[i];
return c;
}
Su paralelizacin sera:
{
double c = 0;
#pragma omp parallel for reduction(+:c)
c += a[i]*b[i];
return c;
}
17/08/11
25/37
El esquema OpenMP
Paralelizar bloques de cdigo

Adems de paralelizar ciclos, es posible paralelizar bloques
#pragma omp parallel
{
// ... codigo a ejecutar en paralelo...
int thread = omp_get_thread_num();
}
omp_get_thread_num regresa el nmero de thread actual.
17/08/11
26/37
El esquema OpenMP
Paralelizar secciones de cdigo

Se puede hacer que varias secciones de cdigo se ejecuten de forma simultnea
#pragma omp parallel sections
{
#pragma omp section
{
// ... algo de codigo
}
#pragma omp section
{
// ... otro codigo
}
}
17/08/11
27/37
El esquema OpenMP
Variables private and shared

En el ejemplo del producto punto:
{
double c = 0;
#pragma omp parallel for reduction(+:c)
{
c += a[i]*b[i];
}
return c;
}
OpenMP hace considera a y b como variables compartidas (shared), es decir, todos los threads
las pueden accesar y modificar.
Para las variables del ciclo i y de la reduccin c, OpenMP hace un copias de las variables al stack
de cada thread, con lo cual se convierten a privadas (private). Al terminar se sumarn las c de
cada thread en la variable c que ahora se considerar shared.
Adems, todas las variables declaradas dentro del bloque parallel sern privadas.
Tambin es posible decidir de forma explcita que variables queremos que tengan un
comportamiento privado o shared.
17/08/11
28/37
El esquema OpenMP
El siguiente ejemplo muestra como:

int i;
int j[10];
float* a;
float* b;
#pragma omp parallel private(i,j) shared(a,b)
{
int k;
// ... codigo ...
}
En este caso, tanto i, j y k sern privadas y a y b sern compartidas.
17/08/11
29/37
El esquema OpenMP
Schedule
Por default, al paralelizar un ciclo el nmero de iteraciones se divide por igual entre cada thread.
Sin embargo, esto no es eficiente si las iteraciones tardan tiempos diferentes en ejecutarse.
Es posible hacer entonces reajustar la distribucin de iteraciones de forma dinmica, esto se hace
con schedule.
#pragma omp parallel for schedule(type[, chunk_size])
{
c[i] = a[i] + b[i];
}
Los tipos de schedule son:

static Las iteraciones se dividen en chunks de un tamao definido.
dynamic Cada thread ejecuta un chunk de iteraciones y al terminar su parte busca otro chunk
para procesar.
guided Cada thread ejecuta un chunk de iteraciones y al terminar su parte busca otro chunk para
procesar. El tamao del chunk vara, siendo grande al iniciar y ste se va reduciendo.
auto La decicin del tipo de schedule es decidido por el compilador/sistema operativo.
runtime El schedule y el tamao del chunk son tomados de la variable sched-var ICV.
17/08/11
30/37
El esquema OpenMP
Otro ejemplo
Ahora veamos la multiplicacin matriz-vector:
void Mult(double* A, double* x, double* y, int rows, int cols)
{
for (int i = 0; i < rows; ++i)
{
double sum = 0;
for (int k = 0; k < cols; ++k)
{
sum += A[i*cols + k]*x[k];
}
y[i] = sum;
}
}
Hay que notar que las operaciones no se interfieren, dado que cada iteracin slo escribe en el
elemento y[i].
17/08/11
31/37
El esquema OpenMP
Secciones crticas
#pragma omp critical
{
mpi.Send(p, tag_x, x);
}
La ejecuccin se restringe a un solo thread a la vez.
17/08/11
32/37

Ejemplo de un programa trabajando en una computadora con 16 procesadores/threads
25.00
Tiempo real [m]
Tiempo ideal [m]
20.00
Tiempo [m]
15.00
10.00
5.00
0.00
1
10
11
12
13
14
15
16
Procesadores
Sea t 1 el tiempo real que tard el resolverse un problema con un core, n el nmero de
procesadores utilizado, el tiempo ideal de ejecucin lo podemos definir como
t1
i n= .
n
17/08/11
33/37
Podemos dar una medida de eficiencia E de un algoritmo

i
t
E= n = 1 .
t n nt n
1.00
0.90
0.80
0.70
Eficiencia
0.60
0.50
0.40
0.30
0.20
0.10
0.00
1
10
11
12
13
14
15
16
Procesadores
17/08/11
34/37

Los compiladores admiten opciones para mejorar el cdigo objeto generado.
Algunas opciones interesantes:
Habilitar SSE. SSE es un conjunto de instrucciones del procesador que hace las operaciones
matemticas de forma ms eficiente.
Incrementar el nivel de optimizacin. Se utilizan varias estrategas para hacer el cdigo ms
rpido, como: desenrollar ciclos, reutilizar valores, poner valores temporales en registros,
mezclar varias lneas de cdigo. Estas optimizaciones pueden evitar que el cdigo se pueda
depurar (el debugger no puede identificar donde inicia o termina una lnea de cdigo).
Eliminar chequeo en las operaciones de punto flotante.
No compilar asserts insertados en el cdigo.
Con GCC sto se hara con
g++ -msse4 -O3 -ffast-math -DNDEBUG <archivo.cpp>
17/08/11
35/37
Preguntas?
Preguntas?
17/08/11
36/37
Para saber ms...
Para saber ms...

En la WWW:
http://openmp.org
http://www.google.com/#&q=openmp+tutorial
Bibliografa:
[Chap08] B. Chapman, G. Jost, R. van der Pas. Using OpenMP: Portable Shared Memory
Parallel Programming. The MIT Press, 2008.
[Drep07] U. Drepper. What Every Programmer Should Know About Memory. Red Hat, Inc.
2007.
[Fog10] A. Fog. Optimizing software in C++. An optimization guide for Windows, Linux and
Mac platforms. Copenhagen University College of Engineering. 2010.
[Wulf95] W. A. Wulf , S. A. Mckee. Hitting the Memory Wall: Implications of the Obvious.
Computer Architecture News, 23(1):20-24, March 1995.
17/08/11
37/37

1 Brevisimo Tutorial de OpenMP

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

1 Brevisimo Tutorial de OpenMP

Cargado por

Copyright:

Formatos disponibles

Brevsimo tutorial de OpenMP

MSc Miguel Vargas-Flix

Nmero de instrucciones por segundo

AMD Athlon XP (5.9G ips)

Intel Pentium III

La evolucin de la velocidad de los procesadores

Tenemos ahora que desarrollar nuevos esquemas para disear algoritmos

La meta es reducir tiempo necesario para realizar una secuencia de instrucciones.

Operaciones matemticas en paralelo

Operaciones matemticas en paralelo

No tan fciles de paralelizar

Operaciones matemticas en paralelo

Sin embargo, podemos reorganizar el proceso como se muestra en la figura:

Operaciones matemticas en paralelo

Evolucin de los procesadores de propsito general

Evolucin de los procesadores de propsito general

Evolucin de los procesadores de propsito general

Hace unos 20+ aos

La velocidad de los procesadores es mayor que la de la memoria RAM. Se introduce en el

Eso de caches es ms eficiente cuando se leen o escriben localidades de memoria continuas

Nota usted la diferencia?

#define ROWS 10000000

#define ROWS 10000000

for (int j = 0; j < COLS; ++j)

for (int i = 0; i < ROWS; ++i)

El cdigo de la izquierda tard 18.76 veces ms que el de la derecha!

Desde hace unos 12+ aos

Slo existe un canal de comunicacin (bus de

El principal cuello de botella es en el acceso a la RAM.

Ahora cada thread se ejecuta en un core. Tenemos un Multi-core computer

Si dos cores tratan de leer de la RAM uno tendr que

El cache con multi-core

Si un core trata de accesar un dato de memoria que ya

Si un core trata de actualizar memoria de la cual existe

El problema aumenta con del esquema de procesamiento

There is not free lunch

Estrategias para mantener a cada core accesando lo ms posible su

Hace unos 8+ aos

Programacin en hilos (threads)

Un programa simple con OpenMP

...la paralelizacin sera:

Para compilar con GCC es necesario agregar:

Cmo se define el nmero de procesadores/threads a utilizar?

Establecer nmero de threads con variables de ambiente

Establecer nmero de threads con cdigo

Paralelizar bloques de cdigo

omp_get_thread_num regresa el nmero de thread actual.

Paralelizar secciones de cdigo

Variables private and shared

El siguiente ejemplo muestra como:

En este caso, tanto i, j y k sern privadas y a y b sern compartidas.

Los tipos de schedule son:

La ejecuccin se restringe a un solo thread a la vez.

Prdida de eficiencia con el aumento de procesadores

Prdida de eficiencia con el aumento de procesadores

Prdida de eficiencia con el aumento de procesadores

Podemos dar una medida de eficiencia E de un algoritmo

Post data: Optimizar el cdigo compilado

Post data: Optimizar el cdigo compilado

Para saber ms...

Para saber ms...

También podría gustarte