Upload
humberto-escalante
View
827
Download
7
Embed Size (px)
DESCRIPTION
Computo en paralelo en LINUX.
Citation preview
Proyecto Final Universidad Autónoma de Sinaloa 2013
1 Facultad de Informática Culiacán
Programación Avanzada, 5 de diciembre de 2013
Grupo:
Carrera
7-4
Instructor Licenciatura en Informática
M.C. Juan Ulises Gallardo
Alumno
Escalante Godinez Alfredo Humberto
Martínez Rubio Luis Carlos
Facultad de Informática Culiacán
Proyecto Final Universidad Autónoma de Sinaloa 2013
2 Facultad de Informática Culiacán
Contenido 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
Proyecto Final Universidad Autónoma de Sinaloa 2013
3 Facultad de Informática Culiacán
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
simultáneamente,1 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.
Proyecto Final Universidad Autónoma de Sinaloa 2013
4 Facultad de Informática Culiacán
Open MP
Introducción
OpenMP es un estándar que define construcciones y su semántica que ayudan a construir
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
Proyecto Final Universidad Autónoma de Sinaloa 2013
5 Facultad de Informática Culiacán
+ + 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. 3
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.
Proyecto Final Universidad Autónoma de Sinaloa 2013
6 Facultad de Informática Culiacán
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 precede.
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 paralelo.
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.
Proyecto Final Universidad Autónoma de Sinaloa 2013
7 Facultad de Informática Culiacán
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
Proyecto Final Universidad Autónoma de Sinaloa 2013
8 Facultad de Informática Culiacán
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
Proyecto Final Universidad Autónoma de Sinaloa 2013
9 Facultad de Informática Culiacán
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
Proyecto Final Universidad Autónoma de Sinaloa 2013
10 Facultad de Informática Culiacán
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
...
Proyecto Final Universidad Autónoma de Sinaloa 2013
11 Facultad de Informática Culiacán
enddo
!$OMP END DO end_clause
Ejemplo de distribución de carga de un bucle.
!$OMP PARALLEL NUM_THREADS(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
Proyecto Final Universidad Autónoma de Sinaloa 2013
12 Facultad de Informática Culiacán
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 WORKSHARE
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
Proyecto Final Universidad Autónoma de Sinaloa 2013
13 Facultad de Informática Culiacán
... !$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 %d\n",iam,np); #pragma omp for for(i=0;i<(np*2);i++)
Proyecto Final Universidad Autónoma de Sinaloa 2013
14 Facultad de Informática Culiacán
{ 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 %d\n", th_id); #pragma omp barrier if ( th_id == 0 ) { nthreads = omp_get_num_threads(); printf("There are %d threads\n",nthreads); } }
return 0; }
Así para compilar este programa llamado hola_openmp.c seria.
[ah.escalante10@uas ~]$ gcc -fopenmp -o hola_openmp hola_openmp.c
Proyecto Final Universidad Autónoma de Sinaloa 2013
15 Facultad de Informática Culiacán
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 MEMBERSHIP CPUS RACK RANK RUNACTION INSTALLATION
Uas : 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
Proyecto Final Universidad Autónoma de Sinaloa 2013
16 Facultad de Informática Culiacán
Open MPI
Introducción
OpenMPI (Message Passing Interface) es un proyecto de librería que combina 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, INTEL, 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.
Proyecto Final Universidad Autónoma de Sinaloa 2013
17 Facultad de Informática Culiacán
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
Proyecto Final Universidad Autónoma de Sinaloa 2013
18 Facultad de Informática Culiacán
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 = %d\n",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
Proyecto Final Universidad Autónoma de Sinaloa 2013
19 Facultad de Informática Culiacán
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.
Proyecto Final Universidad Autónoma de Sinaloa 2013
20 Facultad de Informática Culiacán
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-y-
cursos/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