r12 - 21 Jun 2010 - 16:34:50 - CarlosEscobarYou are here: TWiki >  ECiencia Web  >  GridCSICMain > UsarGRIDCSIC > EjemplosMPIGRIDCSIC

Ejemplos con MPI de cómo usar los recusos GRID-CSIC con gLite

Ejemplos gLite con MPI

Para empezar, debes conectarte a un UI (preferiblemente ui06.ific.uv.es), cargar tu certificado digital y registrarte en la VO del IFIC (más información).

Hay que saber que para mandar trabajos MPI al GRID se deben de seguir unos criterios estándar. Esto se traduce en el uso de dos scripts: mpi-start-wrapper.sh y mpi-hooks.sh. El primero es el encargado de iniciar y configurar todo el sistema y no deberá modificarse. Además, tiene como argumentos el programa a ejecutar y la implementación MPI a usar (MPICH2 u OPENMPI). El segundo se usa para realizar todas las tareas que deseemos en uno de los WN antes y después de ejecutar el programa (o programas) en paralelo como pueden ser: ejecutar algún comando, compilar, etc... Este script lo deberemos modificar a voluntad según nuestras necesidades. Por último, necesitaremos un script JDL para lanzar el trabajo al GRID, el cual deberá tener una estructura específica para lanzar este tipo de trabajos. En particular, siempre tendremos las siguientes líneas:

JobType        = "normal";
CPUNumber      = 48;
Executable     = "mpi-start-wrapper.sh";
Arguments      = "myprogram MPICH2";

Donde "CPUNumber" nos indica el número de procesos en los que se ejecutará nuestro programa, en este caso myprogram. El programa en sí lo indicaremos como un argumento del ejecutable que será siempre el script mpi-start-wrapper.sh, así como la implementación MPI a usar, siendo en este caso MPICH2.

Una vez sabemos todo esto ya estamos listos para probar algunos ejemplos.

HelloWorld

Vamos a empezar con el típico ejemplo de HelloWorld para ver cómo se mandan trabajos con tecnología MPI al GRID-CSIC. Todos los ficheros necesarios para probar este ejemplo se encuentran en el fichero helloworld_mpi.tar.gz. En este caso particular, el script mpi-hooks.sh se encargará de compilar el código fuente con la implementación MPI seleccionada en el script JDL en alguno de los WNs. Puedes ver un extracto de este script aquí:

  cmd="mpicc ${MPI_MPICC_OPTS} -o ${I2G_MPI_APPLICATION} ${I2G_MPI_APPLICATION}.c"
  echo $cmd
  $cmd

El código fuente del programa está en mpi_test.c y básicamente sacará una línea con HelloWorld por proceso. Puedes bajarte el fichero con todos estos scripts de este modo:

wget --no-check-certificate https://twiki.ific.uv.es/twiki/pub/ECiencia/EjemplosMPIGRIDCSIC/helloworld_mpi.tar.gz
tar -xvzf helloworld_mpi.tar.gz

Antes de lanzar nuestro programa al GRID, es mejor probarlo en un UI. Para ello lo compilaremos (ejecutando simplemente make). Para poder compilar fácilmente el programa se adjunta un Makefile que por defecto lo compilará con MPICH2. Para utilizar OPENMPI, puedes editar el Makefile, comentar la línea CC = /opt/openmpi/1.4.1/bin/mpicc -w y descomentar la línea CC = /usr/bin/mpicc -w.

Una vez compilado el programa con la implementación MPI elegida, puedes ejecutarlo en el UI y probarlo usando uno de los siguientes comandos (en este caso, requiriendo 4 procesos en paralelo):

  • MPICH2: mpirun -np 4 ./mpi-test
  • OPENMPI: /opt/openmpi/1.4.1/bin/mpirun -np 4 ./mpi-test

Si todo ha ido bien, deberas ver en pantalla:

   Hello world! from processor 0 out of 4
   Hello world! from processor 1 out of 4
   Hello world! from processor 2 out of 4
   Hello world! from processor 3 out of 4

Una vez hemos comprobado que nuestro programa compila y corre sin problemas en algún UI ya estamos en posición de mandarlo al GRID. Para ello necesitaremos el script JDL adjunto (mpi-test.jdl):

JobType        = "normal";
CPUNumber      = 32;
Executable     = "mpi-start-wrapper.sh";
Arguments      = "mpi-test OPENMPI";
StdOutput      = "mpi-test.out";
StdError       = "mpi-test.err";
InputSandbox   = {"mpi-start-wrapper.sh","mpi-hooks.sh","mpi-test.c"};
OutputSandbox  = {"mpi-test.err","mpi-test.out"};
Requirements = other.GlueCEUniqueId == "ce02.ific.uv.es:2119/jobmanager-pbs-infinibandShort";
VirtualOrganisation = "ific";

Como ya hemos comentado, este script JDL nos permite seleccionar el número de procesos paralelos en los que correrá nuestro programa. Ten en cuenta que "CPUNumber" se refiere al número de cores o procesos, no al número de CPUs reservadas (ya que actualmente las CPUs son multi-core/multi-proceso). Podemos también ver que la elección de la implementación MPI a usar la realizaremos en la línea Arguments, escribiendo OPENMPI o MPICH2 según deseemos. En este caso, enviaremos el código fuente del programa para compilarlo en uno de los WN, aunque también es posible compilarlo en el UI y enviar únicamente el ejecutable. Adicionalmente, hemos adjuntado en el "Requirements" una línea enviará el trabajo a esa cola específica.

También vemos que en el "InputSandbox", a parte del código fuente (mpi-test.c), hay que añadir los dos scripts, mpi-start-wrapper.sh y mpi-hooks.sh. Estos dos archivos serán "estándar" para todos los programas MPI que se manden al GRID.

Para mandar, consultar y finalmente obtener el resultado una vez el trabajo haya finalizado, se deberan usar los siguientes comandos:

 glite-wms-job-delegate-proxy -d $USER
 glite-wms-job-submit -d $USER -o jobId mpi-test.jdl
 glite-wms-job-status -i jobId
 glite-wms-job-output -i jobId

Lattice

Vamos a probar un ejemplo real de Lattice usando un programa que usa MPI. Con el código fuente podemos hacer dos cosas:

  1. Enviarlo o copiarlo a los nodos, compilarlo y ejecutarlo.
  2. Compilarlo en un UI y luego enviar únicamente el ejecutable (y sus dependencias si las hubiera) al GRID.

Veamos ambos casos:

Compilación en un UI y ejecución en el Grid

Esta opción puede que sea la más sencilla, según el tipo de programas que tengamos. Primero copiamos de alguna forma (scp, ftp, etc...) el código fuente al ui06.ific.uv.es y lo compilamos. Para compilar el programa se adjunta un Makefile que por defecto lo compilará con MPICH2. Para utilizar OPENMPI, edita el Makefile, comenta la línea CC = /usr/bin/mpicxx -I./FermiQCD/Version_4.0/Libraries -w y descomenta la línea CC = /opt/openmpi/1.4.1/bin/mpicxx -I./FermiQCD/Version_4.0/Libraries -w.

Para probar este ejemplo con las opciones por defecto (usando MPICH2) podeis hacer:

  mkdir -p /tmp/$USER/mpi_test
  cd /tmp/$USER/mpi_test
  cp /lustre/ific.uv.es/sw/ific/sw/tutorials/mpi/lattice/lattice_src.tar.gz .
  tar -xvzf lattice_src.tar.gz
  make

Esto compilará el código fuente, lo enlazará con sus dependencias (en concreto con la librería FermiQCD) y creará un ejecutable llamado make_mesons_light_new_22_24c3.

Ahora, antes de lanzar el programa al GRID deberíamos probarlo en el UI para asegurarnos de que todo va bien, para ello ejecutaremos uno de los siguientes comandos:

  • MPICH2: mpirun -np 4 ./make_mesons_light_new_22_24c3
  • OPENMPI: /opt/openmpi/1.4.1/bin/mpirun -np 4 ./make_mesons_light_new_22_24c3

Una vez comprobado todo, necesitaremos los archivos estándar mpi-start-wrapper.sh, mpi-hooks.sh, y el script JDL mpi-test_lattice.jdl (dichos archivos se pueden descargar con el fichero mpi-test_lattice.tar.gz). En este caso, el script mpi-hooks.sh no realizará nada antes de ejecutar el programa en paralelo. Por su parte el JDL tiene el siguiente aspecto:

  JobType        = "normal";
  CPUNumber      = 48;
  Executable     = "mpi-start-wrapper.sh";
  Arguments      = "make_mesons_light_new_22_24c3 MPICH2";
  StdOutput      = "mpi-test.out";
  StdError       = "mpi-test.err";
  InputSandbox   = {"mpi-start-wrapper.sh","mpi-hooks.sh","make_mesons_light_new_22_24c3"};
  OutputSandbox  = {"mpi-test.err","mpi-test.out","result.tgz"};
  Requirements = other.GlueCEUniqueId == "ce02.ific.uv.es:2119/jobmanager-pbs-infinibandShort";

Por supuesto, en el caso de querer usar OPENMPI deberemos cambiar MPICH2 por OPENMPI en el JDL (así de simple).

Para bajarnos el tar file, descomprimirlo y mandar el trabajo al GRID, sólo tenemos que ejecutar los siguientes comandos:

wget --no-check-certificate https://twiki.ific.uv.es/twiki/pub/ECiencia/EjemplosMPIGRIDCSIC/mpi-test_lattice.tar.gz
tar xvzf mpi-test_lattice.tar.gz
glite-wms-job-delegate-proxy -d $USER
glite-wms-job-submit -d $USER -o jobId mpi-test_lattice.jdl

Una vez entra en ejecución el trabajo tarda unos 10 minutos en acabar.

Compilación y ejecución en el Grid

Otra opción es compilar nuestro código fuente directamente en alguno de los WNs para luego ejecutarlo, tal y como se hace en el ejemplo "Helloworld". Para ello habrá que mandar (o copiar) todo el código fuente junto con el trabajo. En principio, esto es posible hacerlo simplemente incluyendo los archivos fuente en el "InputSandbox" (por ejemplo, en un archivo comprimido). Sin embargo, si estos archivos superan los 10 MB, no es muy recomendable. Lo mejor es copiar dicho archivo con el código fuente al SE donde se quiere ejecutar nuestro trabajo (en nuestro caso, en lustre). De este modo, desde el script mpi-hooks.sh podemos bajarnos este archivo, descomprimirlo y compilarlo en el WN maestro que esté ejecutando dicho script. La parte relevante de este script será:

  cp /lustre/ific.uv.es/sw/ific/sw/tutorials/mpi/lattice/lattice_src.tar.gz .
  tar -xzf lattice_src.tar.gz

  cmd="mpicxx -I./FermiQCD/Version_4.0/Libraries -w -o ${I2G_MPI_APPLICATION} -DLINUX -DPARALLEL -DUSE_DOUBLE_PRECISION -O3 ${I2G_MPI_APPLICATION}.cpp"
  echo $cmd
  $cmd
  if [ ! $? -eq 0 ]; then
    echo "Error compiling program. Exiting..."
    exit 1
  fi
  ls -lh
  chmod +x ${I2G_MPI_APPLICATION}

Una vez más la selección de la implementación MPI (es decir, MPICH2 u OPENMPI) se realizará desde el JDL. De este modo, mpi-start-wrapper.sh y mpi-test_lattice.jdl permanecen exactamente igual que en el apartado anterior y para lanzar este trabajo sólo deberemos ejecutar:

wget --no-check-certificate https://twiki.ific.uv.es/twiki/pub/ECiencia/EjemplosMPIGRIDCSIC/mpi-test_lattice_compile.tar.gz
tar xvzf mpi-test_lattice_compile.tar.gz
glite-wms-job-delegate-proxy -d $USER
glite-wms-job-submit -d $USER -r ce02.ific.uv.es:2119/jobmanager-pbs-infinibandShort -o jobId mpi-test_lattice.jdl

-- CarlosEscobar - 06 Apr 2010

toggleopenShow attachmentstogglecloseHide attachments
Topic attachments
I Attachment Action Size Date Who Comment
elsegz helloworld_mpi.tar.gz manage 2.1 K 27 May 2010 - 08:14 CarlosEscobar  
elsegz mpi-test_lattice_compile.tar.gz manage 1.4 K 27 May 2010 - 08:42 CarlosEscobar  
elsegz mpi-test_lattice.tar.gz manage 1.5 K 27 May 2010 - 08:50 CarlosEscobar  
Edit | WYSIWYG | Attach | PDF | Raw View | Backlinks: Web, All Webs | History: r12 < r11 < r10 < r9 < r8 | More topic actions
 
Powered by TWiki
This site is powered by the TWiki collaboration platformCopyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding TWiki? Send feedback