Clusters Beowulf/MPI en Linux

En 1994 la NASA construyó un cluster bajo Linux con hardware barato, con 16 procesadores 486 conectados mediante una red local Ethernet, con el objetivo de conseguir alto rendimiento. Para ello se utilizó computación paralela por lo que los programas (escritos en C y Fortran) estaban paralelizados, es decir, utilizaban librerías de Message Passing (PVM y MPI) para que los procesos se ejecutasen en múltiples procesadores siguiendo el paradigma master/esclavo. El proyecto se llamó Beowulf y fue un gran éxito, por lo que actualmente cualquier sistema similar se denomina cluster tipo Beowulf.

MPI (Message Passing Interface, mpi-forum.org) es la especificación de un protocolo de comunicación entre ordenadores para computación paralela, existiendo varias implementaciones del mismo, como MPICH, OpenMPI o LAM/MPI.

MPICH

MPICH (MPI Chameleon, mcs.anl.gov/mpi/mpich/) funciona sobre una capa de abstracción del hardware que le permite ser independiente de la arquitectura y fácilmente portable. Esta capa, llamada ADI (Abstract Device Interface, Interfaz de Dispositivo Abstracto) se encarga de facilitar el acceso al hardware mientras que el resto de MPICH por encima de la ADI se encarga de la sintaxis y la semántica MPI.

Algunos ADIs (también llamados dispositivos) disponibles en MPICH son:

• Clusters Beowulf y workstations:
  - dispositivo ch_p4: es el más general y soporta nodos SMP y sistemas heterogéneos.
  - dispositivo ch_p4mpd: más rápido pero sólo soporta clusters homogéneos monoprocesadores.
• Clusters tipo Grid:
  - dispositivo globus2: soporta sistemas en los que está instalado Globus.
• Multiprocesadores Simétricos:
  - dispositivo ch_shmem: apropiado para sistemas basados en memoria compartida.
  - dispositivo ch_lfshmem: versión de ch_shmem que no utiliza bloqueos.
• Procesadores Paralelos Masivos (MPPs):
  - existen dispositivos para la mayoría de los MPPs existentes, como ch_meiko, ch_nx y ch_mpl.

Instalar MPICH

En Debian disponemos de varias versiones de MPICH:

• mpich-bin: versión con soporte para ch_p4, sólo requiere instalarlo en el master.
• mpich-mpd-bin: versión para ch_p4mpd, requiere el daemon mpd activo en todos los nodos.
• mpich-shmem-bin: versión con soporte para ch_shmem (sistemas con memoria compartida).

Nosotros instalaremos mpich-bin (paquete mpich-bin), la versión para ch_p4.

Configurar MPICH

1. Configurar los nodos: para indicarle a mpirun cuáles son las máquinas disponibles para ejecutar programas MPICH usaremos el archivo /etc/mpich/machines.LINUX, llamado fichero de máquinas (en los nodos con múltiples procesadores indicaremos el número, por ejemplo el nodo slave2 tiene dos procesadores):

   master
   slave1
   slave2:2
   slave3

   Los nombres utilizados en /etc/mpich/machines.LINUX deben estar en /etc/hosts:

   127.0.0.1 localhost
   192.168.0.200 master
   192.168.0.201 slave1
   192.168.0.202 slave2
   192.168.0.203 slave3

2. Habilitar SSH sin password: para que el master pueda ejecutar comandos remotos en los esclavos, MPICH utiliza rsh (Remote Shell) o ssh (Secure Shell). En Debian el comando rsh es un enlace del sistema de alternativas que apunta a /usr/bin/ssh, por lo que MPICH utiliza por defecto conexiones seguras.

   Para disponer de SSH instalaremos en los esclavos el servidor SSH (paquete openssh-server) y los configuraremos para que acepten conexiones desde el master sin pedir password ni pass-phrase (utilizaremos el mismo usuario en todas las máquinas). Para ello:

   - crearemos una clave RSA en el master:

   francis@master:~$ ssh-keygen -t rsa -f ~/.ssh/id_rsa

   - activaremos ssh-agent en el master para que no nos pida la pass-phrase:

   francis@master:~$ eval `ssh-agent -s`
   Agent pid 12297
   francis@master:~$ ssh-add
   Enter passphrase for /home/francis/.ssh/id_rsa:
   Identity added: /home/francis/.ssh/id_rsa (/home/francis/.ssh/id_rsa)

   - copiaremos la clave pública (~/.ssh/id_rsa.pub) en todos los esclavos:

   francis@master:~$ scp ~/.ssh/id_rsa.pub francis@slave1:~/.ssh/id_rsa.pub

   - la añadiremos al final del fichero ~/.ssh/authorized_keys en cada esclavo:

   francis@slave1:~$ cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys

   - y comprobaremos que podemos iniciar sesión SSH en los esclavos sin que nos pida password:

   francis@master:~$ ssh slave1
   francis@slave1:~$

3. Ajustar las variables de entorno: para decirle a MPICH que use SSH debemos establecer la variable de entorno P4_RSHCOMMAND, editando .bashrc y añadiendo la línea:

   export P4_RSHCOMMAND=ssh

   Cargamos .bashrc de nuevo y comprobamos:

   $ source ~/.bashrc
   $ echo $P4_RSHCOMMAND
   ssh

4. Directorio compartido ~/: MPICH, para ejecutar mpirun, requiere que todas las máquinas listadas en /etc/mpich/machines.LINUX tengan un filesystem compartido, para lo cual el master exportará vía NFS el directorio ~/ y los esclavos lo montarán en ~/.

Probar MPICH

MPICH proporciona el comando tstmachines, que comprueba la disponibilidad de las máquinas listadas en /etc/mpich/machines.LINUX para ejecutar programas MPI.

$ tstmachines
These machines seem to be available
    asterix
    slave1
    slave2

Ejecutar programas MPI

MPICH proporciona cuatro comandos para compilar programas MPI:

• mpicc: programas escritos en C.
• mpiCC: programas escritos en C++.
• mpif77: programas escritos en Fortran 77.
• mpif90: programas escritos en Fortran 90.

Por ejemplo, para compilar el programa cpi.c (que calcula PI usando MPI) haremos:

$ mpicc -o cpi cpi.c

Para ejecutar programas MPI utilizaremos el comando mpirun. Por ejemplo, para ejecutar el programa cpi en 2 procesadores haremos:

$ mpirun -np 3 cpi
Process 0 on asterix
Process 2 on slave1
Process 1 on slave2
pi is approximately 3.1416009869231245, Error is 0.0000083333333314
wall clock time = 0.001762

Ejemplo con Python en MPI

Veamos un ejemplo programado en Python para MPI (previamente instalaremos el soporte para Python pyMPI, pympi.sourceforge.net, paquete python-mpi):

$ mpirun -np 3 pyMPI fractal.py
Starting computation
process 1 done with computation!!
process 2 done with computation!!
process 0 done with computation!!
Header length is  54
BMP size is  (400, 400)
Data length is  480000

Se generará el archivo output.bmp, una imagen fractal:

OpenMPI

El proyecto OpenMPI (open-mpi.org) es el resultado de la unión de varias implementaciones de MPI, como LAM/MPI, FT-MPI y LA-MPI.

Es muy similar en su manejo a MPICH, algunas diferencias son:

• instalar paquete openmpi-bin.
• el fichero de máquinas es /etc/openmpi/openmpi-default-hostfile y su sintaxis cambia para nodos con múltiples procesadores:

  master
  slave1
  slave2 slots=2
  slave3

LAM/MPI

LAM/MPI (lam-mpi.org) es una implementación de MPI que utiliza un demonio lamd activo en cada nodo.

• Instalar paquete lam-runtime.
• El fichero de máquinas es /etc/lam/bhost.conf y contiene los nombres completos de las máquinas:

  master.fransberns.com
  slave1.fransberns.com
  slave2.fransberns.com
  slave3.fransberns.com

• Para comprobar si el cluster LAM/MPI puede activarse:

  $ recon

• Para activar el cluster (lamboot lanza el demonio lamd en cada máquina listada en /etc/lam/bhost.conf):

  $ lamboot

• Para ejecutar programas MPI haremos:

  $ mpirun C hello

• Una vez activado el cluster, para comprobar el estado de los nodos:

  $ tping N

• Para apagar el cluster:

  $ lamhalt

• LAM/MPI proporciona la herramienta XMPI (paquete xmpi), que permite ejecutar programas paralelos MPI y monitorizarlos. XMPI no puede activar el cluster, éste tiene que haber sido activado con lamboot antes de lanzar XMPI. Para arrancar XMPI ejecutaremos el comando:

  $ xmpi