PDF de programación - Tutorial de un Cluster Beowulf Casero - Primera Parte

Historia

TuxTips

Artículos

Eventos

Screenshots

Info

Links

Contacto

100% Libre de M$

Principal > Artículos > clusters

Tutorial de un Cluster Beowulf Casero - Primera Parte

unixOZ

[email protected]

Cuando hablamos de clusters, se nos viene inmediatamente a la mente NASA, universidades y lugares con
muchos recursos y conocimientos. Pero un cluster es solo dos o mas computadores funcionando como uno
para desempeñar tareas de forma mas rá pida y eficiente. Generalmente no tenemos la necesidad de correr
aplicaciones en paralelo como individuos ya que no hacemos cosas que requieran grandes velocidades; de
todas formas, para nosotros los curiosos, es interesante ver como contruimos y corremos un
"supercomputador" en nuestra casa.

1. Requerimientos

En mi caso, hice un cluster con 2 computadores, el primero (y mas poderoso) lo llame unix.oz, mientras que
el otro se llamo billy.oz:

unix.oz:

AMD ATHLON K7 600 mhz
256 mb RAM
4.1 Gigabytes de DD
SiS 900 PCI (Tarjeta de Red)
Red Hat Linux 7.2
Kernel 2.4.7-14

billy.oz

CYRIX 233 mhz
32 mb RAM
2 Gigabytes de DD
Fast Ethernet 10/100 Genius
Red Hat Linux 7.2
Kernel 2.4.7-14

Como sólo tenía 2 computadores, no necesite un hub o switch, los conecte mediante un cable cruzado...

2. Configurando el cluster

Un cluster tipo Beowulf funciona con uno de dos librerías de trasnferencia de mensajes: MPI (Message
Passing Interface) o con PVM (Parallel Virtual Machine).

Cuando son compiladas, estas librerías pasan información o data entre las má quinas (o nodos) del cluster.
Ambos usan el protocolo de comunicacion TCP/IP. Tambié n usan el programa rsh (esto es muy inseguro
desafortunadamente pero en un cluster casero no importa tanto) para iniciar las sesiones entra las má quinas.
Este comando (rsh) permite correr comandos UNIX remotamente.

Yo preferi tratar con PVM, y lo siguiente se debe hacer para cada computador que se desee paralelizar, voy a
usar unix.oz:

1.
2.

Entrar como root al sistema
En /etc/hosts

192.168.1.1 unix.oz unix
192.168.1.2 billy.oz billy

3.

Crear el archivo /etc/hosts.equiv. Este contiene el nombre de las máquinas al que rsh puede acceder

unix.oz
billy.oz

4.
5.

6.

7.

Reiniciar y entrar como un usuario "normal".
Probar la red: desde unix.oz hice ping billy.oz.
Si no funciona, deben arreglar la configuracion de su red, si funciona, pasar a paso número 6.
Ahora a probar rsh: desde unix.oz hice rsh usuario_de_billy "ls-l".
Si funciona debería mostrar una lista del directorio de un usuario del otro computador. De lo
contrario,
es VITAL resolver ese problem.a
***Si algo no funciona, no hay que continuar hasta arreglarlo ****

3. Instalar y configurar PVM

Yo
http://www.epm.ornl.gov/pvm/pvm_home.html).

versión

usé

la

3.4

de

Parallel

Virtual Machine

(descargable

de

1.

2.
3.
4.
5.
6.
7.

8.

La bajé a /home/unixoz y como uso Bash, añadí lo siguente a .bashrc PVM_ROOT=$HOME/pvm3
PVM_DPATH=$PVM_ROOT/lib/pvmd export PVM_ROOT PVM_DPATH *** Ojo: Esto puede
variar dependiendo de la distro, kernel, etc. Si no usas Bash, ve en el README al descomprimir
PVM****
Salir del sistema y entrar nuevamente a $HOME (/home/unixoz)
tar zxvf pvm-3.4.tgz
cd pvm3 y luego en $HOME/pvm3 correr make
Si todo sale bien hay que ejecutar pvm Deberías ver pvm> (para salir solo hay que poner halt)
Repetir el proceso con cada computador
Luego puse pvm y para ver cuantos computadores tengo en el cluster puse conf (solo me salió uno, ya
que aun debemos agregar los otros)
Para agregar a billy.oz puse add billy.oz y ahora al poner conf me salen unix.oz y billy.oz AHORA
YA TENEMOS UN CLUSTER DE TIPO BEOWULF!!!!!!!! :)

4. Recursos

Ahora debes aprender a escribir programas en paralelo o usar PVMPOV, un programa para crea imá genes
"super" digitales y diseñado para clusters (http://www.povray.org) Pronto publicaré un tutorial para este, ya
que aun no lo manejo del todo bien.

Tutorial de un Cluster Beowulf Casero [2da parte]

unixOZ

[email protected]

En la primera parte de este tutorial vimos como crear y configurar un cluster beowulf para usar una
herramienta llamada PVM. En este artículo veremos que cosas podemos hacer con nuestro recié n creado
cluster. Una de las principales utilidades son las librerías para la programación en C, y FORTRAN. En este
artículo solo veremos la parte de C, ya que FORTRAN es un lenguaje que no manejo. Es importante
adelantar que lo que viene es para personas que ya tienen un nivel intermedio o avanzado de la programación
en C, esto NO es un tutorial de C.


1. Tecnicas Basicas de la Programación Paralela

Creando aplicaciones para PVM continúa con lo tradicional de la programación de memoria distribuida de
multiprocesadores, como es el nCUBE de Intel. La computación en paralelo puede ser visto desde tres

aspectos bá sicos, todas basadas en la organización de las tareas que requieran el uso de nuestro cluster. El
modelo má s común para programar con PVM es el crowd o multitud; es un conjunto de procesos similares
(tienen el mismo código) pero que ejecutan distintas fracciones de un todo, o la tarea total.

El segundo es el té rmino llamado tree o á rbol, aquí los procesos son copiados de forma tripartita, creando
una relación padre e hijo. Esta té cnica, aunque no es muy usada, permite encajar aplicaciones de las que no
sabemos nada apriori.

La tercera es el hybrid o híbrido, y es una combinación de las dos anteriores; en cualquier punto de la
ejecución de una aplicación la relación entre los procesos de carga puede cambiar. Estas tres clasificaciones
nos pueden ayudar con la topología de nuestro cluster, en mi caso, gracias a esto puedo añadir un tercer nodo
fá cilmente, sin afectar la configuración de unix.oz y billy.oz. A continuación está n las dos primeras de
forma má s detallada.


2. Cómputos CROWD

Estas generalmente usan tres fases. El primero es la inicialización del grupo; el segundo es el cómputo
mismo; y el tercero es el conjunto del output (lo que devuelve el programa al usuario), durante esta fase el
grupo de nodos pueden terminar una sesión. A continuación se puede ver a travé s de un programa de
multiplicación de matrices el uso de esto por medio del algoritomo de Pipe Multiply Roll:

{Matrix Multiplication Using Pipe-Multiply-Roll Algorithm}

{Processor 0 starts up other processes}
if (<my processor number> = 0) then
for i := 1 to MeshDimension*MeshDimension
pvm_spawn(<component name>, . .)
endfor
endif

forall processors Pij, 0 <= i,j < MeshDimension
for k := 0 to MeshDimension-1
{Pipe.}
if myrow = (mycolumn+k) mod MeshDimension
{Send A to all Pxy, x = myrow, y <> mycolumn}
pvm_mcast((Pxy, x = myrow, y <> mycolumn),999)
else
pvm_recv(999) {Receive A}
endif

{Multiply. Running totals maintained in C.}
Multiply(A,B,C)

{Roll.}
{Send B to Pxy, x = myrow-1, y = mycolumn}
pvm_send((Pxy, x = myrow-1, y = mycolumn),888)
pvm_recv(888) {Receive B}
endfor
endfor



3. Cómputos TREE

Para mostrar mejor como esto crea un proceso parecido a la estructura de un á rbol podemos usar un
algoritmo de Parallel Sorting del MIT donde un proceso procesa, para luego compilar un segundo proceso.
Ahora hay dos procesos, y ambos se copian nuevamente para generar dos má s y así sucesivamente, creando
una estructura de un á rbol. Cada proceso es independiente del otro. Este es el código desarrollado por la
MIT:

{ Spawn and partition list based on a broadcast tree pattern. }
for i := 1 to N, such that 2^N = NumProcs
forall processors P such that P < 2^i
pvm_spawn(...) {process id P XOR 2^i}

if P < 2^(i-1) then
midpt: = PartitionList(list);
{Send list[0..midpt] to P XOR 2^i}
pvm_send((P XOR 2^i),999)
list := list[midpt+1..MAXSIZE]
else
pvm_recv(999) {receive the list}
endif
endfor
endfor

{ Sort remaining list. }
Quicksort(list[midpt+1..MAXSIZE])

{ Gather/merge sorted sub-lists. }
for i := N downto 1, such that 2^N = NumProcs
forall processors P such that P < 2^i
if P > 2^(i-1) then
pvm_send((P XOR 2^i),888)
{Send list to P XOR 2^i}
else
pvm_recv(888) {receive temp list}
merge templist into list
endif
endfor
endfor



4. C Para Aplicaciones con PVM

Ahora que ya conocemos lo bá sico de la programación en paralelo, podemos comenzar a explorar las
librerías que nos oferece PVM. Cada programa de PVM debe incluir la librería está ndard, o sea debemos
añadir al comienzo de nuestro programa:

#in clude <pvm 3.h>

Las funciones de PVM generalmente se llaman con:

inf o=pvm _myti d()

info es un int (número entero) que devuelve esa funcion, si pvm _myti d() devolverá una número negativo si
ocurre un error. Cuando finaliza un programa PVM, es recomendable usar la función pvm _exit ().

Para poder escribir un programa en paralelo, las tareas deben ser ejecutados en diferentes procesadores, para
esto se usa pvm _spaw n(). Esa función se usa de referencia para los computos tree. Se llama:

numt=pvm_spawn(mi_tarea, NULL, PvmTaskDefault, 0, n_task, tids)

La pvm_spawn() copia mi_tarea en el nodo que elige PVM. PVM tiene mucha información a la que
podemos acceder, como con pvm_parent(), pvm_config(), pvm_tasks(), etc.


5. Compilando Nuestros Programas

Para compilar mi_programa.c, se usa las siguentes extensiones gené ricas