Este documento presenta un proyecto final sobre programación paralela para la Universidad Autónoma de Sinaloa. Explica brevemente conceptos de computación paralela y luego se enfoca en dos APIs para programación paralela: OpenMP y OpenMPI. Describe las características, historia, ejemplos y uso de OpenMP y OpenMPI para construir programas paralelos que aprovechen múltiples procesadores y núcleos.

1. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
Facultad de Informática Culiacán
Programación Avanzada, 5 de diciembre de 2013
Grupo: 7-4
Carrera
Instructor
Licenciatura en Informática
M.C. Juan Ulises Gallardo
Alumno
Escalante Godinez Alfredo Humberto
Martínez Rubio Luis Carlos
1
Facultad de Informática Culiacán

2. Proyecto Final
Uni versidad Autónoma de Sinaloa
Contenido
2013
Página
Presentación........................................................................................................................3
Open MP .............................................................................................................................4
Introducción.....................................................................................................................4
Historia ............................................................................................................................4
Características..................................................................................................................5
Detalles generales ............................................................................................................6
Cláusula de datos .............................................................................................................6
Cláusula SHARED...........................................................................................................7
Cláusula PRIVATE ..........................................................................................................7
Cláusula DEFAULT .........................................................................................................8
La cláusula FIRSTPRIVATE ..............................................................................................9
Directivas de distribución de datos ..................................................................................10
La directiva !$OMP DO ................................................................................................10
La directiva !$OMP SECTIONS ......................................................................................11
La directiva !$OMP WORKSHARE .................................................................................12
Ejemplos 5 .....................................................................................................................13
Compilación y ejecución..................................................................................................14
Open MPI ..........................................................................................................................16
Introducción...................................................................................................................16
Historia ..........................................................................................................................16
Características................................................................................................................17
Ejemplos ........................................................................................................................18
Compilación y ejecución..................................................................................................18
Conclusión .........................................................................................................................19
Bibliografía.........................................................................................................................20
2
Facultad de Informática Culiacán

3. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
Presentación
La computación Paralela, es muy importante actualmente, al permitir mejorar la velocidad
en la solución de grandes problemas, de modo que se mejora el rendimiento de computo.
La computación paralela es una forma de cómputo en la que muchas instrucciones se
ejecutan simultáneamente, operando sobre el principio de que problemas grandes, a
menudo se pueden dividir en unos más pequeños, que luego son resueltos
simultáneamente (en paralelo). Hay varias formas diferentes de computación paralela:
paralelismo
a
nivel de
bit,
paralelismo
a
nivel de
instrucción, paralelismo
de
datos y paralelismo de tareas. El paralelismo se ha empleado durante muchos años, sobre
todo en la computación de altas prestaciones, pero el interés en ella ha crecido
últimamente debido a las limitaciones físicas que impiden el aumento de la
frecuencia. Como el consumo de energía y por consiguiente la generación de calor de las
computadoras constituye una preocupación en los últimos años. la computación en
paralelo se ha convertido en el paradigma dominante en la arquitectura de computadores,
principalmente en forma de procesadores multinúcleo. La computación paralela es una
forma
de
cómputo
en
la
que
muchas instrucciones se
ejecutan
1
simultáneamente, operando sobre el principio de que problemas grandes, a menudo se
pueden dividir en unos más pequeños, que luego son resueltos simultáneamente (en
paralelo). Hay varias formas diferentes de computación paralela: paralelismo a nivel de bit,
paralelismo a nivel de instrucción, paralelismo de datos y paralelismo de tareas. El
paralelismo se ha empleado durante muchos años, sobre todo en la computación de altas
prestaciones, pero el interés en ella ha crecido últimamente debido a las limitaciones
físicas que impiden el aumento de la frecuencia. Como el consumo de energía y por
consiguiente la generación de calor de las computadoras constituye una preocupación en
los últimos años. la computación en paralelo se ha convertido en el paradigma dominante
en la arquitectura de computadores, principalmente en forma de procesadores multinúcleo.
Los programas
informáticos
paralelos son
más
difíciles
de
escribir
que
los
secuenciales, porque la concurrencia introduce nuevos tipos de errores de software,
siendo
las condiciones
de
carrera los
más
comunes.
La
comunicación
y sincronización entre diferentes subtareas son algunos de los mayores obstáculos para
obtener un buen rendimiento del programa paralelo.
A continuación veremos dos API’s
con las cuales podremos construir programas en
paralelo: OpenMP y OpenMPI.
3
Facultad de Informática Culiacán

4. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
Open MP
Introducción
OpenMP es un estándar que define construcciones y su semántica que ayudan a con struir
programas en paralelo en el modelo de memoria compartida. Fue creado para facilitar la
construcción de programas en este modelo, así como para permitir la portabilidad de estos
programas.1
OpenMP es
una interfaz
de
programación
de
aplicaciones (API)
para
la
programación multiproceso de memoria compartida en múltiples plataformas. Permite
añadir concurrencia a los programas escritos en C, C++ y Fortran sobre la base del
modelo de ejecución fork-join. Está disponible en muchas arquitecturas, incluidas las
plataformas de Unix y de Microsoft Windows. Se compone de un conjunto de directivas de
compilador, rutinas de biblioteca, y variables de entorno que influyen el comportamiento en
tiempo de ejecución.
Definido juntamente por un grupo de proveedores de hardware y de software mayores,
OpenMP es un modelo de programación portable y escalable que proporciona a los
programadores una interfaz simple y flexible para el desarrollo de aplicaciones paralelas
para
las
plataformas
que
van
desde
las
computadoras
de
escritorio
hasta
las supercomputadoras. Una aplicación construida con un modelo de programación
paralela híbrido se puede ejecutar en un clúster de computadoras utilizando ambos
OpenMP y MPI, o más transparentemente a través de las extensiones de OpenMP para
los sistemas de memoria distribuida.2
Historia
OpenMP es administrado por el consorcio sin fines de lucro Architecture Review Board
tecnología OpenMP, definido conjuntamente por un grupo de los principales proveedores
de hardware y software, incluyendo AMD, IBM, Intel, Cray, HP, Fujitsu, Nvidia, NEC,
Microsoft, Texas Instruments, Oracle Corporation , y más.
The Architecture Review Board OpenMP publicó sus especificaciones API primera,
OpenMP Fortran para la 1.0, en octubre de 1997 - octubre del año siguiente lanzaron el C
4
Facultad de Informática Culiacán

5. 2013
Proyecto Final
Uni versidad Autónoma de Sinaloa
+ + estándar de C /. 2000 vio la versión 2.0 de las especificaciones Fortran con la versión
2.0 de las especificaciones + C/C + ser liberado en 2002 - Versión 2.5 es una
especificación + +/Fortran combinada C/C que fue lanzado en 2005.
La versión 3.0 fue lanzado en mayo de 2008 - Incluido en las nuevas características en 3.0
es el concepto de las tareas y la construcción de tareas. Estas nuevas características se
resumen en el Anexo F de las especificaciones de OpenMP 3.0.
La versión 3.1 de la especificación OpenMP fue publicado el 9 de julio de 2011.
Características
El OpenMP se fundamenta en directivas y cláusulas:

Las directivas especifican que hacer.

Las cláusulas indican cómo hacerlo.

Se añaden como comentarios al código.
Tipos de directivas en OpenMP

Directivas de distribución de trabajo.

Directivas de sincronización de tareas.
Tipos de cláusulas en OpenMP

Cláusula de datos.

Cláusula de comportamiento.

Cláusula de sincronía.
Ventajas de OpenMP

Es sencillo ya que no requiere el envío de mensajes como en MPI.

La descomposición de datos es automática.

Admite la paralelización incremental del código.

Mismo código fuente para las versiones serial y paralela.

Permite implementar granularidad gruesa y fina.

Eleva la portabilidad.
Inconvenientes
Requiere un compilador que entienda OpenMP.
El estándar sólo contempla C y Fortran.
5
Facultad de Informática Culiacán
3

6. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
Solo es eficiente en máquinas con memoria compartida
En general la eficiencia paralela es baja.
La escalabilidad está limitada por acceso a la memoria.
Aumentar la eficiencia requiere reestructurar el código.
Detalles generales
Directiva: instrucción de OpenMP que especifica la acción a realizar,
Cláusula: instrucción de OpenMP que impone condiciones a la directiva que le prece de.
Tarea: unidad de ejecución con memora y stack propios.
Región paralela: parte de un programa que es ejecuta por un equipo de tareas que
trabajan conjuntamente.
Región serial: parte de un programa que es ejecutada por una única tarea.
Tarea maestra: tarea que crea a las demás tareas al inicio de una región paralela y cuyo
número de tarea es siempre el 0.
Bloque estructurado: bloque de líneas de código con una única entrada lógica en su parte
superior y una única entrada lógica en su parte superior y una unida salida lógica en su
parte inferior.
Rutina thread-safe: una rutina es thread-safe cuando es capaz de ser utilizada de manera
simultánea e independiente por varias tareas ejecutadas en par alelo.
Race condition: situación no deseable en la que el resultado de un código depende del
orden en el que se ejecutan las tareas.
4
Cláusula de datos
Características generales de estas cláusulas:

Especifican propiedades “paralelas” de las variables.

Pueden aparecen tantas veces como sea necesario.

Pueden usarse con cualquier directiva OpenMP.
6
Facultad de Informática Culiacán

7. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
Restricciones

Una variable no puede aparecer en más de una cláusula

Solo admiten variables que sean visibles desde la subrutina o función que incluya
la cláusula.
Cláusula SHARED
Especifica que una variable es compartida por las tareas:
!$OMP PARALLEL SHARED(c,d)
…
!$OMP END PARALLEL
Características de las variables compartidas:

Todas las tareas ven su contenido.

Todas las tareas pueden cambiar su contenido.

Todas las tareas ven los cambios realizados.
Peculiaridades de las variables compartidas:

Los cambios no son inmediatos (cache coherency).

Pueden requerir de sincronía entre tareas.

Existen algunas limitaciones en Fortran.
Cláusula PRIVATE
Especifica que una variable es privada a cada tarea:
!$OMP PARALLEL PRIVATE(a,b)
...
!$OMP END PARALLEL
7
Facultad de Informática Culiacán

8. Proyecto Final
Uni versidad Autónoma de Sinaloa
Características de las variables privadas:

Cada tarea tiene su propia versión de la variable.

Eso se consigue replicando la variable en memoria.

Las otras tareas no pueden ver su contenido.
Peculiaridades de las variables privadas:

Su valor inicial no está definido.

Tras la región paralela su valor tampoco está definido.

Existen algunas limitaciones.
Cláusula DEFAULT
Especifica el comportamiento por defecto:
integer :: a ,b ,c , d
!$OMP PARALLEL DEFAULT(PRIVATE) SHARED(a)
...
!$OMP END PARALLEL
8
Facultad de Informática Culiacán
2013

9. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
Características de la cláusula:

Sólo puede aparecer una única vez en cada directiva.

Admite tres opciones: PRIVATE, SHARED y NONE.

Con NONE todas las variables deben ser definidas.
Sólo afecta a las variables directamente visibles:
!$OMP PARALLEL DEFAULT(SHARED)
a=1
b=2
call ejemplo (a ,b )
!$OMP END PARALLEL
Las variables definidas dentro de la subrutina ejemplo no se ven afectadas por la cláusula
DEFAULT.
La cláusula FIRSTPRIVATE
Es una extensión de la cláusula PRIVATE:
a=2
b=1
!$OMP PARALLEL PRIVATE(a) FIRSTPRIVATE(b)
...
!$OMP END PARALLEL
Características de las variables FIRSTPRIVATE:

Cada tarea tiene su propia versión de la variable

Eso se consigue replicando la variable en memoria

Las otras tareas no pueden ver su contenido

Su valor es inicializado con la variable original
9
Facultad de Informática Culiacán

10. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
Peculiaridades de las variables FIRSTPRIVATE:

Tras la región paralela su valor no está definido

Existen algunas limitaciones
Cláusulas de datos vistas:
SHARED, PRIVATE, DEFAULT, FIRSTPRIVATE
Cláusulas de datos adicionales:
LASTPRIVATE, REDUCTION, COPYIN, COPYPRIVATE
Condiciones generales a tener en cuenta:

Una variable sólo puede aparecer en una cláusula, salvo en FIRSTPRIVATE y
LASTPRIVATE a la vez

El contador de un bucle siempre es privado

Cada cláusula tiene sus limitaciones
Directivas de distribución de datos
Características de estas directivas:

Distribuyen una carga de trabajo sobre varias tareas

No crean nuevas tareas, usan las ya existentes

Funcionan en regiones seriales y en regiones paralelas

Incluyen al final una sincronización implícita
Restricciones de estas directivas:

Deben ser encontradas por todas las tareas

Sólo pueden contener bloques estructurados de código
La directiva !$OMP DO
Características de la directiva:

Distribuye la carga de un bucle entre las tareas

La descomposición se hace en el espacio de iteraciones

La descomposición es modificable mediante clausulas

El contador es implícitamente declarado PRIVATE
!$OMP DO clause1 clause2 ...
do i = 1 , 1000
...
10
Facultad de Informática Culiacán

11. Proyecto Final
Uni versidad Autónoma de Sinaloa
enddo
!$OMP END DO end_clause
Ejemplo de distribución de carga de un bucle.
!$OMP PARALLEL NUM_T HREADS(10)
!$OMP DO
do i = 1 , 1000
…
enddo
!$OMP END DO
!$OMP END PARALLEL
Restricciones de la directiva !$OMP DO:

En C, el bucle debe ser de un tipo determinado

En Fortran, el bucle no puede ser del tipo do while

El contador debe ser el mismo para todas las tareas

Sólo admite bloques estructurados de código

Las variables SHARED sólo se actualizan al final
La directiva !$OMP SECTIONS
Características de la directiva:

Cada tarea ejecuta una de las secciones

Cada sección es ejecutada una ´única vez

Permite implementar el paralelismo tipo MIMD
!$OMP SECTIONS clause1 clause2 ...
!$OMP SECTION
...
!$OMP SECTION
...
...
!$OMP END SECTIONS end_clause
11
Facultad de Informática Culiacán
2013

12. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
Ejemplo de asignación de tareas
!$OMP SECTIONS
!$OMP SECTION
write(*,*) “Hello”
!$OMP SECTION
write(*,*) “Hi”
!$OMP SECTION
write(*,*) “Bye”
!$OMP END SECTIONS
Restricciones de la directiva:

La manera de asignar secciones a tareas no está definida

Cada sección debe ser un bloque estructurado de código

No se crean nuevas tareas, se usan las existentes

Las variables SHARED sólo se actualizan al final
La directiva !$OMP WORKS HARE
Características de la directiva:

Es especifica para Fortran 95

Explota las capacidades paralelas de Fortran 95

Distribuye las instrucciones matriciales entre las tareas
Soporta las siguientes instrucciones matriciales:
matmul, dot product, sum, product, maxval, minval, count,any, all, spread, pack,
unpack, reshape, transpose, eoshift,cshift, minloc, maxloc, forall, where.
Las instrucciones deben comportarse como si estuvieran en una región serial.
!$OMP WORKSHARE
12
Facultad de Informática Culiacán

13. Proyecto Final
Uni versidad Autónoma de Sinaloa
...
!$OMP END WORKSHARE end_clause
Restricciones de la directiva:

La asignación del trabajo a las tareas no está definida

El compilador debe insertar sincronizaciones suficientes para que el
comportamiento sea el correcto

Sólo se pueden hacer llamadas a funciones que sean del tipo elemental

Existen restricciones al uso de variables PRIVATE
Peculiaridad de la directiva:
Las variables SHARED se actualizan constantemente
Ejemplos 5
Hola mundo
#include <omp.h>
int main()
{
int iam =0, np = 1;
#pragma omp parallel private(iam, np)
{
#if defined (_OPENMP)
np = omp_get_num_threads();
iam = omp_get_thread_num();
#endif
printf(“Hello from thread %d out of %d n”,iam,np);
}
}
Ciclo
#include <omp.h>
int main()
{
int iam =0, np = 1, i=0;
#pragma omp parallel private(iam, np,i)
{
#if defined (_OPENMP)
np = omp_get_num_threads();
iam = omp_get_thread_num();
#endif
printf("Hello from thread %d out of %dn",iam,np);
#pragma omp for
for(i=0;i<(np*2);i++)
13
Facultad de Informática Culiacán
2013

14. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
{
printf("Thread %d, contador %d n",iam,i);
}
}
}
Sección
#pragma omp parallel private(iam, np,i)
{
#pragma omp sections
{
#pragma omp section
printf("Soy el thread %d, en solitario en la seccion 1ª n",iam);
#pragma omp section
printf("Soy el thread %d, en solitario en la sección 2ª n",iam);
#pragma omp section
printf("Soy el thread %d, en solitario en la seccion 3ª n",iam);
}//sections
}//parallel
Compilación y ejecución
Para compilar y ejecutar programas con OpenMP use: gcc -fopenmp -0 <ejecutable>
<fuente> donde ejecutable es el nombre del archivo de salida y fuente es el archivo a
compilar o programa fuente con extension .c.
#include <omp.h>
#include <stdio.h>
int main (int argc, char *argv[]) {
int th_id, nthreads;
#pragma omp parallel private(th_id)
{
th_id = omp_get_thread_num();
printf("Hello World from thread %dn", th_id);
#pragma omp barrier
if ( th_id == 0 ) {
nthreads = omp_get_num_threads();
printf("There are %d threadsn",nthreads);
}
}
return 0;
}
Así para compilar este programa llamado hola_openmp.c seria.
[ah.escalante10@uas ~]$ gcc -fopenmp -o hola_openmp hola_openmp.c
14
Facultad de Informática Culiacán

15. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
Si se requiere agregar funciones matemáticas agregue la librería con: mpicc -lm -fopenmp
-o <ejecutable> <fuente>.
Ejecución de trabajos con OpenMP. Ejecute el programa de forma normal como cualquier
otro programa hecho en C.
[ah.escalante10@uas ~]$ ./hola_openmp
Hello World from thread 1
Hello World from thread 0
There are 2 threads
Observe que no se está usando algún nodo del Clúster ya que esta autentificado en
gridmorelos.uaem.mx que es el front-end o nodo maestro, para usar los nodos del Clúster
se requiere lanzar los programas uno a uno ya que no es un programa MPI, si por ejemplo
se desea usar un nodo en especifico podría lanzarlo de la siguiente manera, primero
observando los nodos disponibles.
[ah.escalante10@uas ~]$ rocks list host
HOST
Uas
MEMBERSHIP CPUS RACK RANK RUNACT ION INSTALLATION
:
Frontend
2
0
0
os
install
compute-0-0: Compute
2
0
0
os
install
compute-0-1: Compute
2
0
1
os
install
...
Al seleccionar el nodo llamado compute-0-0 el comando seria:
[ah.escalante10@uas ~]$ ssh compute-0-0 ./hola_openmp
Hello World from thread 0
Hello World from thread 1
There are 2 threads
Si requiere lanzar los programas OpenMP a lo largo de todo el Cluster podría implementar
un Script que realice esta misma tarea por cada nodo disponible. 6
15
Facultad de Informática Culiacán

16. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
Open MPI
Introducción
OpenMPI (Message Passing Interface) es un proyecto de librería que combin a tecnología y
recursos de otros proyectos (FT-MPI, LA-MPI, LAM/MPI, and PACX-MPI). Es utilizado por
muchas supercomputadoras. 7 Se trata de una API de código abierto desarrollada para
facilitar la programación paralela y/o distribuida que:

Implementa el estándar MPI.

Permite la distribución de procesos de forma dinámica.

Alto rendimiento.

Tolerancia a fallos: capacidad de recuperarse de forma transparente de los fallos
de los

componentes (errores en el envío o recepción de mensajes, fallo de un procesador
o

nodo).

Soporta redes hetereogéneas : permite la ejecución de programas en redes cuyos

ordenadores presenten distinto número de nodos y de procesadores.

Una única librería soporta todas las redes.

Portable: funciona en los sistemas operativos Linux, OS-X , Solaris y en un futuro

próximo en Windows.

Modificable por los instaladores y usuarios finales : presenta opciones de
configuración durante la instalación de la API, la compilación de programas y su
ejecución.
8
Historia
Al diseñarse MPI, se tomaron en cuenta las características más atractivas de los sistemas
existentes para el paso de mensajes, en vez de seleccionar uno solo de ellos y adoptarlo
como el estándar, resultando así, en una fuerte influencia para MPI los trabajos hechos por
IBM, INT EL, NX/, Express, nCUBE's Vernex, p4 y PARMACS. Otras contribuciones
importantes provienen de Zipcode, Chimp, PVM, Chameleon y PICL.
El esfuerzo para estandarizar MPI involucró a cerca de 60 personas de 40 organizaciones
diferentes principalmente de EE.UU. y Europa.
16
Facultad de Informática Culiacán

17. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
La mayoría de los vendedores de computadoras concurrentes estaban involucrados con
MPI, así como con investigadores de diferentes universidades, laboratorios del gobierno e
industrias.
El proceso de estandarización comenzó en el taller de estándares para el paso de
mensajes en un ambiente con memoria distribuida, patrocinado por el Centro de
Investigación en Computación Paralela en Williamsburg, Virginia, Estados Unidos (Abril
29-30 de 1992).
Se llegó a una propuesta preliminar conocida como MPI1, enfocada principalmente en
comunicaciones punto a punto sin incluir rutinas para comunicación colectiva y no
presentaba tareas seguras.
El estándar final por el MPI fue presentado en la conferencia de Supercómputo en
noviembre de 1993, constituyéndose así el foro para el MPI.
En un ambiente de comunicación con memoria distribuida en la cual las rutinas de paso de
mensajes de nivel bajo, los beneficios de la estandarización son muy notorios. La principal
ventaja al establecer un estándar para el paso de mensajes es la portabilidad y el ser fácil
de utilizar. MPI-1 apareció en 1994, el estándar MPI-2 fue lanzado en 1997.
Características

Cumple el standar MPI-2

Distribución de procesos de forma dinámica

Alto rendimiento en todas las plataformas

Administración de trabajos rápida y fiable

Tolerancia a fallos de red y procesos

Soporte de redes hetereogéneas

Una única librería soporta todas las redes

Herramientas de Run-time

Muchos planificadores de trabajos soportados

Portable y mantenible

Modificable por los instaladores y usuarios finales

Mensajes de error internacionalizados

PIs documentadas

Lista de correo activa 10
17
Facultad de Informática Culiacán

18. Proyecto Final
Uni versidad Autónoma de Sinaloa
Ejemplos
include <stdio.h>
#include <mpi.h>
int main(int argc, char **argv)
{
int size, rank;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
printf("SIZE = %d RANK = %dn",size,rank);
MPI_Finalize();
return(0);
}
Compilación y ejecución
Para compilar utilizamos la siguiente instrucción:
mpic++ your_code_file.c
Ejecución del recién programa compilado
mpirun -np <no. of Processors> ./a.out
18
Facultad de Informática Culiacán
2013

19. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
Conclusión
Para empezar no sabíamos que existía la forma de poder desarrollar programas en
paralelo, es decir, que cada procesador se encarga de una tarea específica equivalente a
la que van a realizar los demás procesadores para aprovechar al máximo los recursos de
la computadora. Dicho esto, pareciera que nuestra programación es obsoleta. Sin
embargo, también se le puede considerar un área de oportunidad.
Las dos opciones de API’s aquí mostradas para el desarrollo de programas de computo en
paralelo las considero buenas y fáciles de aprender si se pone entusiasmo.
Aquí el problema mayor que veo más que aprender a utilizar bien estás herramientas es
aprender a desmenuzar las tareas de tal forma que sean equitativas para cada uno de los
procesadores que lo va a ejecutar.
19
Facultad de Informática Culiacán

20. Proyecto Final
Uni versidad Autónoma de Sinaloa
2013
Bibliografía
1. Instituto de Ingeniería – Universidad Autónoma de México
ftp://ftp.iingen.unam.mx/IINGEN/Taller-Super-Computo/jueves24mayo/openmp.pdf
2. Open MP – Wikipedia
http://es.wikipedia.org/wiki/OpenMP
3. Web Academia
http://centrodeartigos.com/articulos-informativos/article_69704.html
4. Universidad Politécnica de Madrid
http://webserver.dmt.upm.es/zope/DMT/Members/hermanns/docencia-ycursos/introduccion-programacion-paralela/Clase_2_Programacion_Paralela_OpenMP.pdf
5. Universidad de Murcia
http://dis.um.es/~domingo/apuntes/PPCAP/1011/PPCAP_1011_OpenMP.pdf
6. Universidad Autónoma del Estado de Morelos
http://www.gridmorelos.uaem.mx/?option=com_content&view=article&id=55&Itemid=71
7. Open MPI – Wikipedia
http://en.wikipedia.org/wiki/Open_MPI
8. Universidad de Murcia
http://dis.um.es/~domingo/apuntes/AlgProPar/0910/exposicion1/MunozPablo -OpenMPI.pdf
9. Computación en paralelo
http://es.wikipedia.org/wiki/Computaci%C3%B3n_paralela
10. MPI – Wikipedia
http://es.wikipedia.org/wiki/Interfaz_de_Paso_de_Mensajes
20
Facultad de Informática Culiacán