computo en paralelo con openmp y openmpi

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



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



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.

http://es.wikipedia.org/wiki/Instrucci%C3%B3n_(inform%C3%A1tica)

http://es.wikipedia.org/wiki/Paralelismo_de_datos


http://es.wikipedia.org/wiki/Paralelismo_de_tareas

http://es.wikipedia.org/wiki/Arquitectura_de_computadores

http://es.wikipedia.org/wiki/Microprocesador

http://es.wikipedia.org/wiki/Instrucci%C3%B3n_(inform%C3%A1tica)

http://es.wikipedia.org/wiki/Computaci%C3%B3n_paralela#cite_note-1


http://es.wikipedia.org/wiki/Paralelismo_de_tareas

http://es.wikipedia.org/wiki/Arquitectura_de_computadores

http://es.wikipedia.org/wiki/Microprocesador

http://es.wikipedia.org/wiki/Algoritmo_paralelo

http://es.wikipedia.org/wiki/Error_de_software

http://es.wikipedia.org/wiki/Condici%C3%B3n_de_carrera

http://es.wikipedia.org/wiki/Sincronizaci%C3%B3n



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

http://es.wikipedia.org/wiki/Interfaz_de_programaci%C3%B3n_de_aplicaciones

http://es.wikipedia.org/wiki/Multiproceso

http://es.wikipedia.org/wiki/Memoria_compartida

http://es.wikipedia.org/wiki/Computaci%C3%B3n_concurrente

http://es.wikipedia.org/wiki/Bifurcaci%C3%B3n_(sistema_operativo)

http://es.wikipedia.org/wiki/Arquitectura_de_computadoras

http://es.wikipedia.org/wiki/Pragma#Programaci.C3.B3n

http://es.wikipedia.org/wiki/Pragma#Programaci.C3.B3n

http://es.wikipedia.org/wiki/Variable_de_entorno

http://es.wikipedia.org/wiki/Portabilidad

http://es.wikipedia.org/wiki/Escalabilidad

http://es.wikipedia.org/wiki/Supercomputadora

http://es.wikipedia.org/wiki/Computaci%C3%B3n_paralela


http://es.wikipedia.org/wiki/Cluster_(inform%C3%A1tica)

http://es.wikipedia.org/wiki/Interfaz_de_Paso_de_Mensajes

http://es.wikipedia.org/w/index.php?title=Memoria_distribuida&action=edit&redlink=1



+ + 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.



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.



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



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



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



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

...



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


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



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


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



... !$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++)



{ 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



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


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



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



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.



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

http://es.wikipedia.org/wiki/Williamsburg

http://es.wikipedia.org/wiki/Virginia

http://es.wikipedia.org/wiki/Estados_Unidos



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



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.



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


10. MPI – Wikipedia


ftp://ftp.iingen.unam.mx/IINGEN/Taller-Super-Computo/jueves24mayo/openmp.pdf

http://es.wikipedia.org/wiki/OpenMP

http://centrodeartigos.com/articulos-informativos/article_69704.html

http://webserver.dmt.upm.es/zope/DMT/Members/hermanns/docencia-y-cursos/introduccion-programacion-paralela/Clase_2_Programacion_Paralela_OpenMP.pdf

http://webserver.dmt.upm.es/zope/DMT/Members/hermanns/docencia-y-cursos/introduccion-programacion-paralela/Clase_2_Programacion_Paralela_OpenMP.pdf

http://dis.um.es/~domingo/apuntes/PPCAP/1011/PPCAP_1011_OpenMP.pdf

http://www.gridmorelos.uaem.mx/?option=com_content&view=article&id=55&Itemid=71

http://en.wikipedia.org/wiki/Open_MPI

http://dis.um.es/~domingo/apuntes/AlgProPar/0910/exposicion1/MunozPablo-OpenMPI.pdf



computo en paralelo con openmp y openmpi

Technology