PDF de programación - Programación en Memoria Compartida - Computación Matricial y Paralela

Computación Matricial y Paralela

Programación en Memoria

Compartida

Javier Cuenca

Domingo Giménez

Dpto. de Ingeniería y Tecnología de Computadores

Dpto. de Informática y Sistemas

Universidad de Murcia

http://dis.um.es/~domingo

Univ. Politécnica de Cartagena

1

Contenido
 Tipos de paralelismo 
 Programación en Memoria Compartida
 OpenMP: Nociones básicas
 OpenMP: Constructores
 OpenMP: Funciones de librería
 OpenMP: Variables de entorno
 OpenMP: Ejemplos básicos

Univ. Politécnica de Cartagena

2

Tipos de paralelismo

Las variaciones entre los paradigmas por:

• Diferencia de esfuerzo invertido en escribir programas paralelos. 
Algunos lenguajes requieren menos esfuerzo para el programador, 
mientras  que  otros  requieren  menos  trabajo  pero  generan  un 
código menos eficiente.
•  Un  determinado  paradigma  de  programación  puede  ser  más 
eficiente que otros al programar sobre determinadas arquitecturas 
paralelas.
•  Distintas  aplicaciones  tienen  diferentes  tipos  de  paralelismo  y 
por tanto se han desarrollado diferentes lenguajes de programación 
para explotarlos.

Univ. Politécnica de Cartagena

3

Tipos de paralelismo

• Explícito : 

– El 

algoritmo 

especificar 
explícitamente  cómo  cooperan  los  procesadores 
para resolver un problema específico.

paralelo 

debe 

– La tarea del compilador es sencilla, en cambio la 

del programador es bastante difícil.

– Normalmente en Memoria Distribuida con Paso 

de Mensajes.

Univ. Politécnica de Cartagena

4

Tipos de paralelismo

• Implícito:

inserta 

las 

compilador 

– Se usa un lenguaje de programación secuencial y 
el 
instrucciones 
necesarias  para  ejecutar  el  programa  en  un 
computador paralelo.

– El compilador tiene que analizar y comprender 
las  dependencias  para  asegurar  un  mapeo 
eficiente en el computador paralelo.

– Normalmente en Memoria Compartida.

Univ. Politécnica de Cartagena

5

Tipos de paralelismo

• Muchos 

lenguajes  de  programación  para  memoria 
compartida  o  paso  de  mensajes  son  básicamente  lenguajes 
secuenciales  aumentados  mediante  un  conjunto  de  llamadas 
de sistema especiales. Estas llamadas producen primitivas de 
bajo  nivel  para  el  paso  de  mensajes,  sincronización  de 
procesos, exclusión mutua, etc. 

• El  problema  de  estos  lenguajes  es  la  portabilidad  entre 
arquitecturas. Han aparecido librerías como PVM, MPI (paso 
de mensajes), OpenMP (memoria compartida), con primitivas 
independientes del computador.

Univ. Politécnica de Cartagena

6

Programación en Memoria
Compartida

• Los  programadores  ven  el  programa  como  una 
colección de procesos accediendo a una zona central 
de variables compartidas.

• Más de un proceso podría acceder a la misma zona 
instante  produciendo 
lenguajes 
estos 

compartida  en  el  mismo 
resultados 
impredecibles. 
proporcionan  primitivas  para 
problemas de exclusión mutua.

Los 

resolver 

Univ. Politécnica de Cartagena

7

Programación en Memoria
Compartida

• Primitivas para la creación de procesos
Se  realiza  mediante  una  llamada  al  sistema  que  crea 

procesos idénticos al proceso padre. 

Estos  procesos  comparten 

las  variables  declaradas 
"compartidas"  por  los  procesos  padre  así  como  las 
llaves declaradas e inicializadas por los procesos padre. 
En la mayoría de computadores de espacio de direcciones 

compartido, esta operación se llama fork. 

Cuando  todos  los  subprocesos  terminan,  se  mezclan 

usando otra primitiva, normalmente llamada join. 

Univ. Politécnica de Cartagena

8

Programación en Memoria
Compartida

En  vez  de  crear  procesos  al  principio  de  la  ejecución, 
podemos  tener  un  solo  proceso,  llamado  proceso 
maestro. 

Cuando el maestro necesita realizar una tarea en paralelo, 
crea un  número predeterminado de procesos, llamados 
procesos esclavos. 

Cuando  la  tarea  se  completa,  los  procesos  esclavos 

terminan y devuelven el control al proceso maestro.

Univ. Politécnica de Cartagena

9

Programación en Memoria
Compartida

asignar 

variables 

• Existen 

para 
compartidas entre los procesos.

primitivas 

• Hay dos tipos de variables: 

– compartidas (shared) 
– locales (private)

Univ. Politécnica de Cartagena

10

Programación en Memoria
Compartida

• Primitivas para la exclusión mutua y sincronización.
Una sección crítica contiene código que sólo puede ser ejecutado por 

un procesador en un momento determinado. 

Las 

Los 

lenguajes  proporcionan 

(locks)  para  ayudar  al 
programador  a  cumplir  la  exclusión  mutua  en  la  ejecución  de 
secciones críticas.

llaves 

de 

primitivas 

sincronización  de  barreras

 (barrier 
synchronization) 
los  procesos  necesitan 
sincronizarse antes de que acabe la ejecución. Cada proceso espera 
en la barrera a los otros procesos, y después de la sincronización 
todos los procesos continúan con su ejecución.

se  usan  cuando 

Univ. Politécnica de Cartagena

11

Programación en Memoria
Compartida

Compiladores Paralelizantes

• Programa secuencial. El compilador se encarga de paralelizarlo.
• Normalmente en sistemas de memoria compartida.
• Paralelizan bucles: dividen el trabajo entre los distintos procesadores
• Si puede haber dependencia de datos no paraleliza:

para i=1 to n

a[i]=b[i]+a[i­1]

finpara

• Se puede forzar la paralelización con opciones de compilación, o con 

directivas (OpenMP).

• Generan  ficheros  con  información  de  bucles  paralelizados  y  no 

paralelizados, y el motivo.

Univ. Politécnica de Cartagena

12

OpenMP: Nociones básicas

• Modelo de programación fork-join, con generación de

múltiples threads (procesos ligeros).

•

Inicialmente se ejecuta un thread hasta que aparece
el primer constructor paralelo, se crean threads
esclavos y el que los pone en marcha es el maestro.

• Al final del constructor se sincronizan los threads y

continúa la ejecución el maestro.

Univ. Politécnica de Cartagena

13

OpenMP: Nociones básicas

#include <omp.h>
int main() {
int iam =0, np = 1;
#pragma omp parallel private(iam, np)
{
np = omp_get_num_threads();
iam = omp_get_thread_num();
printf(“ Hello from thread %d out of %d \n” , iam, np);
}
}

Univ. Politécnica de Cartagena

14

OpenMP: Nociones básicas

 Fichero a incluir: omp.h
 Constructores: #pragma omp ...
 Cláusulas: private(iam, np) ...
 Funciones de librería: omp_...(...)
 Variables de entorno. Indican forma de 

ejecución.

Univ. Politécnica de Cartagena

15

OpenMP: Constructores

Forma general:

#pragma omp nombre-directiva [cláusulas]

Univ. Politécnica de Cartagena

16

OpenMP: Constructores

Constructor parallel

#pragma omp parallel [cláusulas]

bloque

 
Se crea un grupo de threads. El que los pone en marcha actúa de

maestro. Los otros son los esclavos.

Univ. Politécnica de Cartagena

17

OpenMP: Constructores

Constructor parallel

Con cláusula if se evalúa su expresión y si da valor distinto de

cero se crean los threads, si es cero se hace en secuencial.

El número de threads a crear se obtiene por variables de entorno

o llamadas a librería.

Hay barrera implícita al final de la región.
Cuando dentro de una región hay otro constructor paralelo, cada
esclavo crearía otro grupo de threads esclavos de los que sería
el maestro.

Cláusulas (private, firstprivate, default, shared, copyin y
reduction) para indicar la forma en que se accede a las
variables.

Univ. Politécnica de Cartagena

18

OpenMP: Constructores

Constructor for

#pragma omp for [cláusulas]

bucle for

 
La parte de inicialización del for debe ser una asignación.
La parte de incremento debe ser una suma o resta.
La parte de evaluación es la comparación de una variable entera sin
signo con un valor, utilizando un comparador mayor o menor
(puede incluir igual).

Los valores que aparecen en las tres partes del for deben ser

enteros.

Univ. Politécnica de Cartagena

19

OpenMP: Constructores

Constructor for

Las iteraciones se ejecutan en paralelo por threads que ya

existen.

Hay barrera al final a no ser que se utilice la cláusula

nowait. 

Hay una serie de cláusulas

firstprivate,
lastprivate y reduction) para indicar la forma en que se
accede a las variables.

(private,

 

Univ. Politécnica de Cartagena

20

OpenMP: Constructores

Constructor for

Una cláusula schedule indica la forma como se dividen las iteraciones del

for entre los threads:

schedule(static,tamaño) las iteraciones se dividen según el tamaño, y la

asignación se hace estáticamente a los threads. Si no se indica el
tamaño se divide por igual entre los threads.

schedule(dynamic,tamaño) las iteraciones se dividen según el tamaño y
se asignan a los threads dinámicamente cuando van acabando su
trabajo.

schedule(guided,tamaño) las iteraciones se asignan dinámicamente a los

threads pero con tamaños decrecientes.

schedule(runtime) deja la decisión para el tiempo de ejecución, y se

obtienen de la variable de entorno OMP_SCHEDULE.

Univ. Politécnica de Cartagena

21

OpenMP: Constructores

#pragma omp sections [cláusulas]

Constructor sections

{

[#pragma omp section]

bloque

[#pragma omp section

bloque

Hay una serie de cláusulas
(private, firstprivate,
lastprivate y reduction) para
indicar la forma en que se
accede a las variables.

Cada sección se ejecuta por un thread.

 

...
]

}

Hay barrera al final a no ser que se utilice la cláusula nowait.

Univ. Politécnica de Cartagena

22

OpenMP: Constructores

Constructores combinados:

#pragma omp parallel for [cláusulas]
bucle for

Es forma abreviada de directiva parallel que tiene una única

directiva for, y admite sus cláusulas menos la nowait.

#pragma omp parallel sections [cláusulas]

Es forma abreviada de directiva parallel que tiene una únic