MPICH2 : Instalacion y Configuracion

El primer paso es conseguir el codigo fuente de mpich2 (Version 1.3.1)  de la siguiente url :

http://www.mcs.anl.gov/research/projects/mpich2/downloads/tarballs/1.3.1/mpich2-1.3.1.tar.gz

El resultado de  descomprimir el archivo : mpich2-1.3.1.tar.gz es una carpeta mpich2-1.3.1 , al ingresar a esta carpeta se puede observar los siguientes archivos

24K -rw-r–r–.  1 gpu gpu  21K Nov  2  2007 README.winbin.rtf
8.0K -rw-r–r–.  1 gpu gpu 7.9K Feb 27  2009 COPYRIGHT.rtf
4.0K -rw-r–r–.  1 gpu gpu 2.0K Feb 27  2009 COPYRIGHT
52K -rw-r–r–.  1 gpu gpu  51K Nov 15  2009 mpich2-doxygen.in
8.0K -rwxr-xr-x.  1 gpu gpu 4.7K May 28  2010 mpl.vcproj
12K -rw-r–r–.  1 gpu gpu 9.8K May 28  2010 mpi.vcproj
228K -rw-r–r–.  1 gpu gpu 228K May 28  2010 mpich2.vcproj
116K -rw-r–r–.  1 gpu gpu 114K May 28  2010 mpich2s.vcproj
548K -rw-r–r–.  1 gpu gpu 546K Sep  3 15:00 mpich2.sln
12K -rwxr-xr-x.  1 gpu gpu 9.5K Sep  9 15:36 makewindist.bat
16K -rw-r–r–.  1 gpu gpu  16K Oct  5 14:53 mpi.def
24K -rw-r–r–.  1 gpu gpu  22K Oct  5 14:53 mpich2.def
12K -rw-r–r–.  1 gpu gpu 9.3K Nov  6 10:02 Makefile.sm
236K -rw-r–r–.  1 gpu gpu 234K Nov 11 02:55 configure.in
328K -rwxr-xr-x.  1 gpu gpu 325K Nov 14 14:43 winconfigure.wsf
8.0K -rw-r–r–.  1 gpu gpu 4.1K Nov 14 14:43 RELEASE_NOTES
48K -rw-r–r–.  1 gpu gpu  46K Nov 16 10:20 CHANGES
4.0K drwxr-xr-x.  3 gpu gpu 4.0K Nov 17 11:48 contrib
4.0K drwxr-xr-x.  2 gpu gpu 4.0K Nov 17 11:48 confdb
1.3M -rwxr-xr-x.  1 gpu gpu 1.3M Nov 17 11:49 configure
40K -rw-r–r–.  1 gpu gpu  40K Nov 17 11:51 README
4.0K drwxr-xr-x.  7 gpu gpu 4.0K Nov 17 11:51 test
4.0K drwxr-xr-x. 15 gpu gpu 4.0K Nov 17 11:51 src
24K -rw-r–r–.  1 gpu gpu  21K Nov 17 11:51 Makefile.in
4.0K drwxr-xr-x.  8 gpu gpu 4.0K Nov 17 11:51 examples
4.0K drwxr-xr-x. 13 gpu gpu 4.0K Nov 17 11:51 doc
4.0K drwxr-xr-x.  4 gpu gpu 4.0K Nov 17 11:51 maint
4.0K drwxr-xr-x.  4 gpu gpu 4.0K Nov 17 11:56 man
4.0K drwxr-xr-x.  4 gpu gpu 4.0K Nov 17 11:56 www

Entre ellos el importante es el archivo configure , con el se compilara e instalara mpich en nuestro sistema .

Para instalar mpich se debe crear una carpeta : mkdir /usr/local/mpich2_install

Para comenzar la compilacion es necesario el siguiente comando :

[root@localhost mpich2-1.3.1]# ./configure –prefix=/usr/local/mpich2_install/ –enable-shared –with-pm=mpd

[root@localhost mpich2-1.3.1]# make

[root@localhost mpich2-1.3.1]# make install

Esto instala mpich2 en la carpeta /usr/local/mpich2_install .

drwxr-xr-x. 2 root root 4096 Dec 11 15:59 bin
drwxr-xr-x. 2 root root 4096 Dec 11 15:58 etc
drwxr-xr-x. 3 root root 4096 Dec 11 15:58 include
drwxr-xr-x. 3 root root 4096 Dec 11 15:59 lib
drwxr-xr-x. 2 root root 4096 Dec 11 15:59 sbin
drwxr-xr-x. 8 root root 4096 Dec 11 15:59 share

Lo siguiente es actulizar las variables  $PATH  y $LD_LIBRARY_PATH del usuario que desee desarrollar usando la libreria mpich2 . Esto se logra editando el archivo .bashrc que se encuentra en el $HOME de cada usuario , agregando las siguientes dos lineas :

export PATH=/usr/local/mpich2_install/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/mpich2_install/lib:$LD_LIBRARY_PATH

Luego procedemos a guardas los cambios.  Lo mas sano luego de esto es reiniciar la sesion .

Ahora podemos probar si es que las utilidades son encontradas en el nuevo $PATH , para esto es suficiente hacer un which mpicc .

El siguiente paso es configurar el manejador de procesos  (opcion –with-mp al momento de hacer el ./configure) , para esto hay que crear un archivo llamado .mpd.conf en el $HOME -del usuario que desea lanzar trabajos mpi- con una » palabra secreta » . El contenido del archivo .mpd.cond seria algo parecido a esto MPD_SECRETWORD=cluster y darle los permisos necesarios  (chmod 600 .mpd.conf) .

Para usar mpich2 en la maquina donde se han seguido estos pasos , solo es levantar el demonio mpd , con la siguiente instruccion :

[user@localhost ~]$ mpd &

Al hacer un ps aux | grep mpd se deberia obtener algo parecido a esto :

[user@localhost ~]$ ps uax | grep mpd
user      18117  0.2  1.1 184524 11576 pts/6    S    20:44   0:00 python2.6 /usr/local/mpich2_install/bin/mpd
user      18120  0.0  0.0 103200   836 pts/6    S+   20:45   0:00 grep mpd

Con lo que ya tendriamos este nodo preparado para comenzar a programar usando mpich2 .

Otra manera de verificar que el entorno mpich2 esta listo para ser usado es con el comando mpdtrace -l , la salida deberia ser similar a la siguiente :

[user@localhost ~]$ mpdtrace -l
localhost.localdomain_55930 (127.0.0.1)

Ejemplo de mpich2 : Comunicacion Simple en C

/*simpleMPI.c*/

#include <stdio.h>
#include «mpi.h»

int main(argc,argv)
int argc;
char *argv[];
{
int myid;
char line[128];

MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD,&myid);

fprintf ( stdout, «Imprimiendo en stdout…%d\n», myid );
fprintf ( stderr, «imprimiendo en stderr…%d\n», myid );
fgets ( line, 128, stdin );
fprintf ( stdout, «Desde stdin: %s», line );

MPI_Finalize();
return 0;
}

Para compilarlo : mpicc -o simpleMPI simpleMPI.c

Para correr el ejecutable usando 4 procesos : mpirun -np 4 ./simpleMPI

Programacion Paralela

¿ Por que estudiar el paralelismo ?

Considera tu aplicacion favorita :

 

Un procesador puede darte los resultados en N horas , entonces

¿Porque no usar N procesadores?

Para asi reducir el tiempo de procesamiento en solo 1 hora (Teoricamente) .

La idea es simple :

Paralelismo = Usar multiples procesadores para una tarea

 

La computacion paralela es el uso de multiples computadores (o procesadores) trabajando juntos en una tarea comun..Cada procesador  trabaja en su porcion del trabajo,  ademas a los procesadores se les permite cambiar informacion con otros procesadores. Esto es en esencia la computacion paralela .

La computacion paralela nace de tres factores limitantes  :

• Limitaciones inherentes de una sola CPU :
  • Memoria disponible.
  • Performance.

• La computacion paralela permite :
  • Resolver problemas que no caben en una sola CPU.
  • Resolver problema que no pueden ser resueltos en un tiempo rasonable.
• Podemos correr :
  • Grandes problemas con rapidez y analizar mas casos .
  • Simulaciones a resoluciones mas finas .
  • Simulaciones fisicas mas realistas

Veamos esto con un par de ejemplos : Pronostico del Tiempo

La atmosfera puede ser modelada en regiones de  3 dimenciones (o celdas) , un aproximado de 500 x 10**6 cells. Los calculos en cada celda son repetidos varias veces por un modelo que depende del tiempo. Alrededor de 200 operaciones puntos flotante por celda en una unidad de tiempo , haciendo un total (aproximado)  de 10**11 operaciones punto flotante por unidad de tiempo.

Haciendo unas pocas operaciones a mano  :

10 dias de prediccion con 10 minutos de resolucion => 1.5×10**14 flops

100 Mega Flops tomarian cerca de 17 dias

1.7 Tera Flops tomarian 2 minutos

NUMERICAL WEATHER PREDICTION – http://www.wrh.noaa.gov/wrh/NWP.php

Atmospheric Sciences (University of Illinoius,  Urbana-Champaign) – http://www.atmos.illinois.edu

Como segundo ejemplo : Modelando el movimiento de cuerpos astronomicos

Metodo de Fuerza Bruta . Cada cuerpo es atraido por la fuerza gravitacional de los otros cuerpos.  El movimiento de cada cuerpo se puede predecir mediante el calculo de la fuerza total experimentada por este cuerpo . Para N cuerpos ,  cada cuerpo experimenta la fuerza de N-1 cuerpos haciendo N**2 operaciones en cada intervalo de tiempo .

Una galaxia tiene 10**11 estrellas => Esto se traduce en 10**9 años para una  iteracion

Podemos ver los tipos de paralelismo desde dos perspectivas distintas :

• Paralelismo de los datos
  • Cada procesador realiza la misma tarea en datos diferentes
• Paralelismos de las tareas
  • Cada procesador realiza una tarea diferente .

Mucho algoritmos paralelizados permiten asignar tareas diferentes a procesadores diferentes, por jemplo partes de un conjunto de datos de entrada puede ser dividida y procesada por diferentes procesadores , o una malla de diferencias finitas puede ser dividida entre los procesadores que se encuentres disponibles .

Esto genera una necesidad de mas tecnicas para implementar los programas paralelos , una solucion a esto es el estandar de facto : MPI .