User Tools

Site Tools


wiki:tutorial_slurm

SLURM

Slurm (Simple Linux Utility for Resource Management) es un sistema de gestión de recursos en clusters de computadoras. Nos permite asignar los recursos computacionales (núcleos, memoria, gpu, etc.) de una forma equitativa a medida de su disposición.


Entidades manejadas por los servicios de Slurm

Nodos: Sistema multiprocesador perteneciente al cluster

Particiones: es un mecanismo de agrupar en forma lógica los nodos. Sin importar el número de nodos que se disponen se puede crear la cantidad de particiones que uno desee. Un nodo puede pertenecer a varias particiones. Cada partición tiene sus propios parámetros: tiempo límite de trabajo, usuarios permitidos, que nodos la componen, etc.

Trabajos: Un trabajo o job es la asignación de recursos a un usuario específico por una cantidad de tiempo determinada.

Tareas: Son el conjunto de programas (seriales o paralelas) que serán ejecutadas dentro de un trabajo.


Modo uso de Slurm


Slurm proporciona una interfaz de usuario donde se pueden ejecutar comandos slurm desde el shell del sistema operativo.
El usuario envía los trabajos y Slurm se encarga de ubicarlo en la cola de espera. Si hay recursos pasa a ejecutar el trabajo.
En caso de estar ocupado el trabajo se ejecutará cuando estén disponibles los recursos.

En general, los pasos a seguir para ejecutar un trabajo son:


1. Analizar los recursos que dispone el cluster y las necesidades del trabajo. Utilizar los comandos "sinfo" y "squeue".

2. Enviar el trabajo :                       A) Interactivamente. Se utiliza "srun" con los parámetros de configuración del trabajo. Es una forma rápida de enviar el trabajo a ejecución, pero con varias restricciones.                       B) Utilizar scripts. Se debe crear un script con la configuración del trabajo. Usar "sbatch" y sus parámetros.

3. (Opcional) Verificar la correcta configuración. Utilizar el comando "scontrol show job <JOBID>".

4. (Opcional) Recuperar la información que resulta de la ejecución del trabajo. Interactivamente: los resultados, errores, etc. se verán en el shell.
Scripts: se guardan en un archivo llamado slurm-<JOBID>.out



Comandos para ejecutar un trabajo


Envía el trabajo para ser ejecutado a Slurm. Si no posee recursos para el trabajo el shell queda esperando a que se desocupen. Si posee recursos ejecuta el programa y nos proporciona por la consola los resultados de la ejecución

  • [usuario@clemente ~]$ srun <NombrePrograma>

 

Parámetros de srun

-n, --ntasks: especifica la cantidad de tareas para correr. Por default 1 tarea por 1 CPU.

-j, --job-name: especifica el nombre de la tarea

-N, --nodes: especifica el mínimo de nodos que deben ser reservado para el trabajo

-p, --partition: especifica la partición donde el trabajo se va a ejecutar.

-v -vv -vvv : Aumenta el nivel de verbosidad.

-o <ArchivoSalida>: Redirecciona la salida al archivo especificado.



Ejemplos srun


  • [usuario@clemente ~]$ srun -n 2 miPrograma

Ejecuta miPrograma en 2 tareas, cada una en diferentes CPUs


  • [usuario@clemente ~]$ srun -n 6 --tasks-per-node=3 --partition=debug miPrograma

Ejecuta miPrograma en 6 tareas distribuida en dos nodos, en la partición debug.




SBATCH es la forma más adecuada de ejecutar un trabajo. Se utiliza un archivo script para la configuración de Slurm y del sistema operativo para ejecutar el trabajo.

  • [usuario@clemente ~]$ srun <NombreScriptSlurm>

 

Parámetros de sbatch

-n, --ntasks: especifica la cantidad de tareas (procesos) para correr

-j, --job-name: especifica el nombre de la tarea

-N, --nodes: especifica el mínimo de nodos que deben ser reservado para el trabajo

-p, --partition: especifica la partición donde el trabajo se va a ejecutar.

--mail-user <email>--mail-type=ALL:  Envía un mail notificando el cambio de estado en el trabajo



Ejemplos sbatch


  • [usuario@clemente ~]$ sbatch -N2 --name=<nombre>  --mail-user= <email@address.com>  --mail-type=ALL <NombreScriptSlurm> /li>

Ejecuta el script NombreScriptSlurm en 2 nodos y enviá mail por cambios de estados


  • [usuario@clemente ~]$ sbatch -N3 --time=60

Ejecuta el script NombreScriptSlurm en 3 nodos y como limite máximo de tiempo 1 hora .



Para más información ver la sección "Script de lanzamientos y comandos SBATCH".




Comandos para ver información


Ejemplo de sinfo en el cluster Clemente

  • [usuario@clemente ~]$ sinfo
  •  
  • PARTIT  AVAIL    TIMELIMIT  NODES    STATE    NODELIST
  • debug   up            2:00    4      idle   clemente[01-04]
  • batch*  up      5-00:00:00    3      idle   clemente[01-03]
  • small   up         1:00:00    1      drain  clemente04
  • gpu     up      3-00:00:00    1      drain  clemente04

 

Información que brinda sinfo:

PARTIT: Nombre de la partición. El sufijo * indica que es la partición por defecto.

AVAIL: Estado de la partición: UP es disponible y DOWN no disponible.

TIMELIMIT: Tiempo máximo de ejecución de un trabajo, en formato días-horas:minutos:segundos.

NODES: Cantidad de nodos.

STATE: Estados de los nodos en formato:

      ALLOCATED: El nodo esta asignado a uno o más trabajos.

      ALLOCATED+: El nodo esta asignado a uno o más trabajos. Y uno o más trabajos estan completados.

      COMPLETING: Todos los trabajos asociados con este nodo están en proceso de COMPLETAR. Este estado de nodo se eliminará cuando todos los procesos del trabajo hayan finalizado y el programa epilog SLURM (si lo hubiera) haya finalizado.

      DOWN:  El nodo no está disponible para su uso. SLURM puede colocar nodos automáticamente en este estado si ocurre alguna falla. Los administradores del sistema también pueden colocar nodos explícitamente en este estado

      DRAINED: El nodo no está disponible para su uso por solicitud del administrador del sistema.

      DRAINING: El nodo está actualmente ejecutando un trabajo, pero no se asignará a trabajos adicionales. El estado del nodo se cambiará para indicar DRAINED cuando finalice el último trabajo en él.

      FAIL:  Se espera que el nodo falle pronto y no esté disponible para su uso por solicitud del administrador del sistema.

      IDLE:  El nodo no está asignado a ningún trabajo y está disponible para su uso.

      MAINT:  El nodo está actualmente en una reserva con un valor de bandera de "mantenimiento" o está programado para reiniciarse.

      UNKNOWN:  El controlador SLURM acaba de comenzar y el estado del nodo aún no se ha determinado.

NODELIST: Nombres de los nodos.


Ejemplo de squeue en el cluster Clemente

  • [usuario@clemente ~]$ squeue
  •  
  • PARTITION   JOBID     PRIO     NAME         USER      ST    TIME  NO   CPU     GRES NODELIST(REASON)
  • batch       2255      4294     flash      usuario3    PD    0:00  2    112    (null)  (Resources)
  • batch       2254      4294     IM3SHAPE   usuario2    R  5:10:30  2    112    (null)  clemente[1-2]
  • batch       2253      4294     cli        usuario1    R  1:05:07  1    56    (null)   clemente3

Información que brinda squeue:

PARTITION: El nombre de la partición en que esta asignado el trabajo.

JOBID: El identificador del trabajo. Es útil tener presente este identificador porque es muy usados, tanto para los nombre por estándar y como parámetro en la ejecución de otros comandos slurm.

PRIO: La prioridad del trabajo. Actualmente todos tienen la misma prioridad y se van asignando por orden de llegada.

NAME: Nombre del trabajo.

USER: El usuario que envío el trabajo.

TIME: El tiempo que lleva ejecutando en formato días-horas:minutos:segundos. Si su tiempo es 0:00:00 significa que esta esperando por recursos.

NO: La cantidad de nodos reservados para el trabajo.

CPU: La cantidad de cores totales que se reservo.

GRES: Los aceleradores que reservo.

NODELIST(REASON): Los nodos en los que está corriendo el trabajo, o la razón por la que no se está ejecutando todavía. Algunas razones comunes son:

      Resources:  No hay recursos libres en el cluster para ejecutarlo.

      Priority:  Hay trabajos con mayor prioridad esperando a ser ejecutados.

      AssociationJobLimit:  El usuario ya excede la cantidad de trabajos máxima en ejecución simultánea.

      JobHeldUser:  El usuario ha suspendido el trabajo.

      JobHeldAdmin:  Un administrador ha suspendido el trabajo.

      Launch failed requeued held:  SLURM encontró un error al iniciar el trabajo y lo ha suspendido.


Para mostrar la información de todos los nodos "scontrol show nodes".
Para mostrar la información de un nodo en particular scontrol show nodes <NombreNodo>

Ejemplo de scontrol show nodes <NombreNodo>

  • [usuario@clemente ~]$scontrol show nodes clemente01
  • NodeName=clemente01 Arch=x86_64 CoresPerSocket=14
  •   CPUAlloc=56 CPUErr=0 CPUTot=56 CPULoad=56.02
  •   AvailableFeatures=(null)
  •   ActiveFeatures=(null)
  •   Gres=gpu:0
  •    NodeAddr=clemente01 NodeHostName=clemente01 Version=17.11
  •   OS=Linux 3.10.0-514.el7.x86_64 #1 SMP Tue Nov 22 16:42:41 UTC 2016
  •   RealMemory=1 AllocMem=0 FreeMem=107711 Sockets=2 Boards=1
  •   State=ALLOCATED ThreadsPerCore=2 TmpDisk=0 Weight=1 Owner=N/A MCS_label=N/A
  •   Partitions=debug,batch
  •   BootTime=2018-06-04T14:56:55 SlurmdStartTime=2018-06-25T11:53:33
  •   CfgTRES=cpu=56,mem=1M,billing=56
  •   AllocTRES=cpu=56
  •   CapWatts=n/a
  •   CurrentWatts=0 LowestJoules=0 ConsumedJoules=0
  •   ExtSensorsJoules=n/s ExtSensorsWatts=0 ExtSensorsTemp=n/s

 

Explicación de scontrol show nodes

Resaltado en color rojo se puede observar los datos más importantes: la cantidad de núcleos del nodo, si posee GPU, el nombre del nodo y las particiones a la que pertenece


Por la complejidad de la configuración existen muchos casos donde el trabajo se realiza incorrectamente, para corroborar los parámetros del trabajo podemos utilizar el comando "scontrol show job <JOBID>".


Ejemplo de scontrol show job <JOBID>

  • [usuario@clemente ~]$scontrol show nodes
  •   JobId=2256 JobName=nombreTrabajo
  •   UserId=usuario GroupId=usuarios MCS_label=N/A/li>
  •   Priority=4294900462 Nice=0 Account=iate QOS=normal
  •   JobState=RUNNING Reason=None Dependency=(null)
  •   Requeue=1 Restarts=0 BatchFlag=1 Reboot=0 ExitCode=0:0
  •   RunTime=00:34:52 TimeLimit=3-00:00:00 TimeMin=N/A
  •   SubmitTime=2018-07-19T14:07:48 EligibleTime=2018-07-19T14:07:48
  •   StartTime=2018-07-19T16:42:06 EndTime=2018-07-22T16:42:06 Deadline=N/A
  •   PreemptTime=None SuspendTime=None SecsPreSuspend=0
  •   LastSchedEval=2018-07-19T16:42:06
  •   Partition=batch AllocNode:Sid=clemente:3638
  •   ReqNodeList=(null) ExcNodeList=(null)
  •   NodeList=clemente02
  •   BatchHost=clemente02
  •   NumNodes=1 NumCPUs=56 NumTasks=1 CPUs/Task= 56 ReqB:S:C:T=0:0:*:*
  •   TRES=cpu=56,node=1,billing=56
  •   Socks/Node=* NtasksPerN:B:S:C=0:0:*:* CoreSpec=*
  •   MinCPUsNode=56 MinMemoryNode=0 MinTmpDiskNode=0
  •   Features=(null) DelayBoot=00:00:00
  •   Gres=(null) Reservation=(null)
  •   OverSubscribe=OK Contiguous=0 Licenses=(null) Network=(null)
  •   Command=/mnt/test/submit.sh
  •   WorkDir=/mnt/test
  •   StdErr=/mnt/test/slurm-2256.out
  •   StdIn=/dev/null
  •   StdOut=/mnt/test/slurm-2256.out
  •   Power=

 

Explicación de scontrol show job <JOBID>

En  rojo   se puede observar el id del trabajo(JOBID) y el nombre del trabajo, los cuales son útiles para identificarlos cuando se utilizan otros comandos.

En  amarillo   el tiempo transcurrido y el tiempo máximo que puede ejecutarse el trabajo, en formato días-horas:minutos:segundos.

En  gris  el nombre de la partición y la lista de nodos que tiene asignado el trabajo.

En  naranja   el número de nodos, de CPU y de tareas.

En  celeste   si al trabajo se le asigno una GPU.

En  rosa   las dirección y los nombres del archivo suministrado a Slurm, el archivo donde se escribirán los errores, el archivo de entrada de parámetros y el archivo donde se guardan los logs del trabajo.




Comandos para cancelar un trabajo


  • [usuario@clemente ~]$ scancel <JOBID>

Cancela el trabajo con el <JOBID>


  • [usuario@clemente ~]$ scancel --signal=TERM 1111.4 1111.8

Enviá la señal SIGTERM a las tareas 4 y 8 del trabajo 1111




Script Slurm



El script de slurm esta dividido en dos componentes:

  • Comandos Slurm.

  • Comandos Shell UNIX.

Comandos Slurm

Los comandos de slurm son necesarios para la iniciación y configuración de los cluster. Tienen una estructura definida donde deben cumplirse ciertas reglas:   

  • Empezar el comando con #SBATCH, que describen los recursos que requiere un trabajo.
  • Cuando se encuentra un comando unix, el resto de las líneas #SBATCH son IGNORADAS.


Preámbulo

Hashbang

La primera línea del archivo siempre debe indicar el shell para el que está escrito el script:
#!/bin/bash

Nombre

El trabajo debe tener un nombre, que le sirva para identificarlo.
#SBATCH   --name=nombre

Notificaciones al usuario (opcional)

Se le puede pedir a Slurm que notifique por mail al usuario sobre actualizaciones del estado de su trabajo.
#SBATCH   --mail-type=ALL
#SBATCH   --mail-user=direccion@de.email

Recursos

Luego se deben enumerar los recursos requeridos por el trabajo.

Cola de ejecución

Los distintos recursos de cómputo de los clusters del CCAD son accesibles a través de colas de trabajos, que son líneas de espera en las que trabajos con requerimientos similares se ubican hasta que les toque su turno y los recursos requeridos estén disponibles. Las colas disponibles y sus límites dependen del cluster. En el script del trabajo:
#SBATCH   --partition=nombreParticion

Procesos (tasks)

Cada trabajo en ejecución consiste en una cantidad de procesos corriendo simultáneamente.

  • Los procesos se distribuyen en uno o más nodos de cómputo (computadoras del cluster) según la disponibilidad de recursos.
  • En las aplicaciones MPI, la cantidad de procesos es el parámetro -np pasado a mpirun o mpiexec.
  • En el script, la cantidad P de procesos del trabajo se define con la línea:

  • #SBATCH --ntasks=P
  • Alternativamente se puede pedir una distribución exacta y equitativa de procesos entre nodos del cluster, especificando explícitamente la cantidad de nodos N y cantidad de procesos por nodo PPN:
  • #SBATCH --nodes=N
    #SBATCH --ntasks-per-node=PPN

Hilos (cpus, opcional)

Cada proceso del trabajo puede dividirse en más de un hilo de ejecución.

  • En las aplicaciones OpenMP, la cantidad de hilos por proceso está definida en la variable de entorno OMP_NUM_THREADS.
  • A cada hilo del trabajo se le asigna un core de algún procesador del cluster.
  • En el script, la cantidad H de hilos por proceso se define con la línea:
  • #SBATCH   --cpus-per-task=H
Entonces, si un trabajo pide P procesos con H hilos cada uno, requerirá P * H cores para correr.


Tiempo

Es necesario especificar el tiempo máximo de ejecución del trabajo. Si el trabajo se excede de este tiempo, Slurm mata los procesos en ejecución y cancela el trabajo. Este tiempo debería ser lo más cercano posible al tiempo de ejecución real del trabajo. El formato del campo es días-horas:minutos.
#SBATCH --time=dd-hh:mm

Aceleradores (opcional)

Algunos de los clusters del CCAD disponen de coprocesadores para cómputo (GPUs y Xeon Phi). Los aceleradores se piden por nodo, y son visibles a todos los procesos corriendo dentro del mismo nodo. Para pedir G GPUs por nodo:
#SBATCH --gres=gpu:G

Comandos Unix

Comandos shell UNIX (generalmente bash) y comandos que extienden el shell (por ejemplo Environment Module). Son tareas a ser ejecutadas en el momento de que corre el trabajo.


Entorno

Primero es necesario importar la configuración de las variables de entorno compartida por todos los usuarios:
. /etc/profile

Módulos

Una vez cargado el entorno por defecto tenemos acceso al sistema de módulos, por lo que cargamos los requeridos por el programa a correr:
module load modulo/del/programa

Variables de entorno (opcional)

Luego podemos configurar variables de entorno que afecten el funcionamiento de nuestro programa.
Un caso común es el de las aplicaciones OpenMP, que deben configurar la variable OMP_NUM_THREADS al mismo valor que fue dado en #SBATCH --cpus-per-task.
export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK

Lanzamiento del programa

Finalmente se lanza el programa. Para esto se debe utilizar srun, que suplanta la funcionalidad de mpirun o mpiexec lanzando tantos procesos como sean necesarios en los recursos asignados al trabajo.
srun programa




Ejemplos Script Slurm



  • Tarea: ejecutar programas utilizando gpu
  • Ejecución: sbatch submit_gpu_job.sh
  • Partición: gpu
  • Tiempo máximo: 7 días

submit_gpu_job.sh
  1. #!/bin/bash
  2.  
  3. ### Las líneas #SBATCH configuran los recursos de la tarea
  4. ### (aunque parezcan estar comentadas)
  5.  
  6. ### Nombre de la tarea
  7. #SBATCH --job-name=gpu_job
  8.  
  9. ### Cola de trabajos a la cual enviar.
  10. #SBATCH --partition=gpu
  11. #SBATCH --gres=gpu:1
  12.  
  13. ### Procesos a largar.
  14. ### Por defecto, se usa un solo proceso para tareas GPU.
  15. #SBATCH --ntasks-per-node=1
  16.  
  17. ### Tiempo de ejecucion. Formato dias-horas:minutos.
  18. #SBATCH --time 7-0:00
  19.  
  20. ### Script que se ejecuta al arrancar el trabajo
  21.  
  22. ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  23. ### No tocar
  24. . /etc/profile
  25.  
  26. ### Cargar los módulos para la tarea
  27. # FALTA: Agregar los módulos necesarios
  28. module load cuda/6.5
  29.  
  30. ### Largar el programa
  31. # FALTA: Cambiar el nombre del programa
  32. srun NOMBRE_DEL_PROGRAMA

  • Tarea: ejecutar programas utilizando mpi
  • Ejecución: sbatch submit_mpi_job.sh
  • Partición: batch
  • Tiempo máximo: 2 días

submit_mpi_job.sh
  1. #!/bin/bash
  2.  
  3. ### Las líneas #SBATCH configuran los recursos de la tarea
  4. ### (aunque parezcan estar comentadas)
  5.  
  6. ### Nombre de la tarea
  7. #SBATCH --job-name=mpi_job
  8.  
  9. ### Tiempo de ejecucion. Formato dias-horas:minutos.
  10. #SBATCH --time 2-0:00
  11.  
  12. ### Numero de procesos a ser lanzados.
  13. #SBATCH --ntasks=2
  14.  
  15. ### Nombre de partcion
  16. #SBATCH --partition=batch
  17.  
  18. ### Script que se ejecuta al arrancar el trabajo
  19.  
  20. ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  21. ### No tocar
  22. . /etc/profile
  23.  
  24. ### Cargar los módulos para la tarea
  25. # FALTA: Agregar los módulos necesarios
  26. module load etc...
  27.  
  28. ### Largar el programa con los cores detectados
  29. ### La cantidad de nodos y cores se detecta automáticamente
  30. # FALTA: Cambiar el nombre del programa
  31. srun NOMBRE_DEL_PROGRAMA

  • Tarea: ejecutar programas utilizando openmp
  • Ejecución: sbatch submit_openmp_job.sh
  • Partición: batch
  • Tiempo máximo: 2 días

submit_openmp_job.sh
  1. #!/bin/bash
  2.  
  3. ### Las líneas #SBATCH configuran los recursos de la tarea
  4. ### (aunque parezcan estar comentadas)
  5.  
  6. ### Nombre de la tarea
  7. #SBATCH --job-name=openmp_job
  8.  
  9. ### Cola de trabajos a la cual enviar.
  10. #SBATCH --partition=batch
  11.  
  12. ### Procesos a largar.
  13. ### Es OpenMP, o sea que un proceso en un nodo y muchos hilos.
  14. #SBATCH --ntasks=1
  15.  
  16. ### Hilos por proceso
  17. ### Poner el mismo valor acá que en OMP_NUM_THREADS/MKL_NUM_THREADS
  18. #SBATCH --cpus-per-task=16
  19.  
  20. ### Tiempo de ejecucion. Formato dias-horas:minutos.
  21. #SBATCH --time 2-0:00
  22.  
  23. ### Script que se ejecuta al arrancar el trabajo
  24.  
  25. ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  26. ### No tocar
  27. . /etc/profile
  28.  
  29. ### Configurar OpenMP/MKL/etc con la cantidad de cores detectada.
  30. export OMP_NUM_THREADS=16
  31. export MKL_NUM_THREADS=16
  32.  
  33. ### Cargar los módulos para la tarea
  34. # FALTA: Agregar los módulos necesarios
  35. module load etc...
  36.  
  37. ### Largar el programa
  38. # FALTA: Cambiar el nombre del programa
  39. srun NOMBRE_DEL_PROGRAMA

  • Tarea: ejecutar programas utilizando gpu
  • Ejecución: sbatch submit_gpu_job.sh
  • Partición: gpu
  • Tiempo máximo: 3 días

submit_gpu_job.sh
  1. #!/bin/bash
  2.  
  3. ### Las líneas #SBATCH configuran los recursos de la tarea
  4. ### (aunque parezcan estar comentadas)
  5.  
  6. ### Nombre de la tarea
  7. #SBATCH --job-name=gpu_job
  8.  
  9. ### Cola de trabajos a la cual enviar.
  10. #SBATCH --partition=gpu
  11. #SBATCH --gres=gpu:1
  12.  
  13. ### Procesos a largar.
  14. ### Por defecto, se usa un solo proceso para tareas GPU.
  15. #SBATCH --ntasks-per-node=1
  16.  
  17. ### Tiempo de ejecucion. Formato dias-horas:minutos.
  18. #SBATCH --time 3-0:00
  19.  
  20. ### Script que se ejecuta al arrancar el trabajo
  21.  
  22. ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  23. ### No tocar
  24. . /etc/profile
  25.  
  26. ### Cargar los módulos para la tarea
  27. # FALTA: Agregar los módulos necesarios
  28. module load gpu cuda/9.1.85
  29.  
  30. ### Largar el programa
  31. # FALTA: Cambiar el nombre del programa
  32. srun NOMBRE_DEL_PROGRAMA
  33.  

  • Tarea: ejecutar programas utilizando mpi
  • Ejecución: sbatch submit_mpi_job.sh
  • Partición: batch
  • Tiempo máximo: 3 días

submit_mpi_job.sh
  1. #!/bin/bash
  2.  
  3. ### Las líneas #SBATCH configuran los recursos de la tarea
  4. ### (aunque parezcan estar comentadas)
  5.  
  6. ### Nombre de la tarea
  7. #SBATCH --job-name=mpi_job
  8.  
  9. ### Tiempo de ejecucion. Formato dias-horas:minutos.
  10. #SBATCH --time 3-0:00
  11.  
  12. ### Numero de procesos a ser lanzados.
  13. #SBATCH --ntasks=2
  14.  
  15. ### Nombre de partcion
  16. #SBATCH --partition=batch
  17.  
  18. ### Script que se ejecuta al arrancar el trabajo
  19.  
  20. ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  21. ### No tocar
  22. . /etc/profile
  23.  
  24. ### Cargar los módulos para la tarea
  25. # FALTA: Agregar los módulos necesarios
  26. module load clemente ...
  27.  
  28. ### Largar el programa con los cores detectados
  29. ### La cantidad de nodos y cores se detecta automáticamente
  30. # FALTA: Cambiar el nombre del programa
  31. srun NOMBRE_DEL_PROGRAMA
  32.  

  • Tarea: ejecutar programas utilizando OPENMP
  • Ejecución: sbatch openmp
  • Partición: batch
  • Tiempo máximo: 3 días

submit_openmp_job.sh
  1. #!/bin/bash
  2.  
  3. ### Las líneas #SBATCH configuran los recursos de la tarea
  4. ### (aunque parezcan estar comentadas)
  5.  
  6. ### Nombre de la tarea
  7. #SBATCH --job-name=openmp_job
  8.  
  9. ### Cola de trabajos a la cual enviar.
  10. #SBATCH --partition=batch
  11.  
  12. ### Procesos a largar.
  13. ### Es OpenMP, o sea que un proceso en un nodo y muchos hilos.
  14. #SBATCH --ntasks=1
  15.  
  16. ### Hilos por proceso
  17. ### Poner el mismo valor acá que en OMP_NUM_THREADS/MKL_NUM_THREADS
  18. #SBATCH --cpus-per-task=56
  19.  
  20. ### Tiempo de ejecucion. Formato dias-horas:minutos.
  21. #SBATCH --time 3-0:00
  22.  
  23. ### Script que se ejecuta al arrancar el trabajo
  24.  
  25. ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  26. ### No tocar
  27. . /etc/profile
  28.  
  29. ### Configurar OpenMP/MKL/etc con la cantidad de cores detectada.
  30. export OMP_NUM_THREADS=56
  31. export MKL_NUM_THREADS=56
  32.  
  33. ### Cargar los módulos para la tarea
  34. # FALTA: Agregar los módulos necesarios
  35. module load clemente etc...
  36.  
  37. ### Largar el programa
  38. # FALTA: Cambiar el nombre del programa
  39. srun NOMBRE_DEL_PROGRAMA
  40.  

  • Tarea: ejecutar programas utilizando gpu
  • Ejecución: sbatch submit_gpu_job.sh
  • Partición: gpu
  • Tiempo máximo: 7 días

submit_gpu_job.sh
  1. #!/bin/bash
  2.  
  3. #### NOTA: ESTE SCRIPT ES VIEJO
  4.  
  5. ### Las líneas #SBATCH configuran los recursos de la tarea
  6. ### (aunque parezcan estar comentadas)
  7.  
  8. ### Nombre de la tarea
  9. #SBATCH --job-name=nombre
  10.  
  11. ### Cantidad de nodos a usar
  12. #SBATCH --nodes=1
  13.  
  14. ### GPUs por nodo (menor o igual 2)
  15. ### OJO: Todos los procesos en un nodo ven ambas GPU con gpu:2!
  16. ### Llamar al programa con /opt/mendieta/bin/split_cpu.sh para dividirlas.
  17. #SBATCH --gres=gpu:1
  18.  
  19. ### Procesos por nodo
  20. #SBATCH --ntasks-per-node=1
  21.  
  22. ### Cores por proceso (OpenMP/Pthreads/etc)
  23. ### Recordar exportar OMP_NUM_THREADS/MKL_NUM_THREADS/etc con el mismo valor
  24. #SBATCH --cpus-per-task=1
  25. export OMP_NUM_THREADS=1
  26.  
  27. ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  28. #SBATCH --time 7-0:00
  29.  
  30. ### Environment setup
  31. . /etc/profile
  32.  
  33. ### Environment modules
  34. module load cuda/5.0
  35.  
  36. ### Ejecutar la tarea
  37. ### NOTA: srun configura MVAPICH2 y MPICH con lo puesto arriba,
  38. ### no hay que llamar a mpirun.
  39. srun algun_programa_gpu
  40.  
  41.  

  • Tarea: ejecutar programas utilizando mpi
  • Ejecución: sbatch submit_mpi_job.sh
  • Partición: batch
  • Tiempo máximo: 7 días

submit_mpi_job.sh
  1. #!/bin/bash
  2.  
  3. ### Las líneas #SBATCH configuran los recursos de la tarea
  4. ### (aunque parezcan estar comentadas)
  5.  
  6. ### Nombre de la tarea
  7. #SBATCH --job-name=programa_mpi
  8.  
  9. ### Cola a usar (capacity, capability, gpu)
  10. #SBATCH --partition=capability
  11.  
  12. ### Cantidad de nodos a usar
  13. #SBATCH --nodes=1
  14.  
  15. ### Cantidad de procesos a lanzar por nodo
  16. ### capacity=16, capability=18, gpu=20
  17. #SBATCH --ntasks-per-node=18
  18.  
  19. ### Cores por proceso (para MPI+OpenMP)
  20. #SBATCH --cpus-per-task=1
  21. export OMP_NUM_THREADS=1
  22. export MKL_NUM_THREADS=1
  23.  
  24. ### GPUs por nodo
  25. ### capacity/capability=0, gpu=1 (K20X) o 2 (M2090)
  26. #SBATCH --gres=gpu:0
  27.  
  28. ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  29. #SBATCH --time 7-0:00
  30.  
  31.  
  32. ### Script que se ejecuta al arrancar el trabajo
  33.  
  34. ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  35. ### No tocar
  36. . /etc/profile
  37.  
  38. ### Cargar los módulos para la tarea
  39. # FALTA: Agregar los módulos necesarios
  40. module load etcetera
  41.  
  42. ### Largar el programa con los cores detectados
  43. ### La cantidad de nodos y cores se detecta automáticamente
  44. # FALTA: Cambiar el nombre del programa
  45. srun programa
  46.  

  • Tarea: ejecutar programas utilizando OPENMP
  • Ejecución: sbatch openmp
  • Partición: batch
  • Tiempo máximo: 3 días

submit_openmp_job.sh
  1. #!/bin/bash
  2.  
  3. ### Las líneas #SBATCH configuran los recursos de la tarea
  4. ### (aunque parezcan estar comentadas)
  5.  
  6. ### Nombre de la tarea
  7. #SBATCH --job-name=programa_openmp
  8.  
  9. ### Cola de trabajos a usar
  10. ### Es OpenMP, no podemos usar más de un nodo, así que capacity
  11. #SBATCH --partition=capacity
  12.  
  13. ### Procesos a largar.
  14. ### Es OpenMP, o sea que un proceso en un nodo y muchos hilos.
  15. #SBATCH --ntasks=1
  16.  
  17. ### Hilos por proceso
  18. ### Poner el mismo valor acá que en OMP_NUM_THREADS/MKL_NUM_THREADS
  19. #SBATCH --cpus-per-task=16
  20.  
  21. ### GPUs (0 o 1)
  22. #SBATCH --gres=gpu:0
  23.  
  24. ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  25. ### Traten de acotarlo.
  26. #SBATCH --time 7-0:00
  27.  
  28. ### Script que se ejecuta al arrancar el trabajo
  29.  
  30. ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  31. ### No tocar
  32. . /etc/profile
  33.  
  34. ### Configurar OpenMP/MKL/etc con la cantidad de cores detectada.
  35. export OMP_NUM_THREADS=16
  36. export MKL_NUM_THREADS=16
  37.  
  38. ### Cargar los módulos para la tarea
  39. # FALTA: Agregar los módulos necesarios
  40. module load etcetera
  41.  
  42. ### Largar el programa
  43. # FALTA: Cambiar el nombre del programa
  44. srun programa
  45.  
  46.  

  • Tarea: ejecutar programas utilizando
  • Ejecución: sbatch submit_gamess.sh
  • Partición: batch
  • Tiempo máximo: 1 días

submit_gamess.sh
  1. #!/bin/bash
  2.  
  3. ### NOTA:
  4. ### GAMESS requiere un directorio ~/scr en el home del usuario para correr
  5.  
  6. ### Cantidad de cores (menor o igual a 16)
  7. #SBATCH --ntasks=16
  8. CORES=16
  9.  
  10. ### Nombre de la tarea
  11. #SBATCH --job-name=gamess
  12.  
  13. ### Correr en un solo nodo hasta que veamos cómo hacer para lanzar en muchos
  14. #SBATCH --nodes=1
  15.  
  16. ### Cores por proceso (OpenMP/Pthreads/etc)
  17. ### GAMESS corre uno solo
  18. #SBATCH --cpus-per-task=1
  19. export OMP_NUM_THREADS=1
  20. export MKL_NUM_THREADS=1
  21.  
  22. ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  23. #SBATCH --time 1-0:00
  24.  
  25. ### Environment setup
  26. . /etc/profile
  27.  
  28. ### Environment modules
  29. module load md/gamess/20130501
  30.  
  31. ### Ejecutar la tarea
  32. ### NOTA: srun configura MVAPICH2 y MPICH con lo puesto arriba,
  33. ### no hay que llamar a mpirun.
  34. rungms $1 00 ${CORES}
  35.  

  • Tarea: ejecutar programas utilizando
  • Ejecución: sbatch submit_gromacs.sh
  • Partición: gpu
  • Tiempo máximo: 7 días

submit_gromacs.sh
  1. #!/bin/bash
  2.  
  3. ### Las líneas #SBATCH configuran los recursos de la tarea
  4. ### (aunque parezcan estar comentadas)
  5.  
  6. ### Usar cola gpu
  7. #SBATCH --partition=gpu
  8.  
  9. ### Nombre de la tarea
  10. #SBATCH --job-name=gromacs
  11.  
  12. ### Cantidad de nodos a usar
  13. #SBATCH --nodes=2
  14.  
  15. ### Procesos por nodo
  16. #SBATCH --ntasks-per-node=1
  17.  
  18. ### GPUs por nodo
  19. #SBATCH --gres=gpu:1
  20.  
  21. ### Cores por nodo
  22. #SBATCH --cpus-per-task=20
  23. export OMP_NUM_THREADS=20
  24. export MKL_NUM_THREADS=20
  25.  
  26. ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  27. #SBATCH --time 7-0:00
  28.  
  29. ### Environment setup
  30. . /etc/profile
  31.  
  32. ### Environment modules
  33. module load md/gromacs/5.0.2
  34.  
  35. ### Largar el progrma en cuestion
  36. srun mdrun_mpi
  37.  

  • Tarea: ejecutar programas utilizando
  • Ejecución: sbatch submit_lammps.sh
  • Partición: gpu
  • Tiempo máximo: 7 días

submit_lammps.sh
  1. #!/bin/bash
  2.  
  3. ### Las líneas #SBATCH configuran los recursos de la tarea
  4. ### (aunque parezcan estar comentadas)
  5.  
  6. ### Nombre de la tarea
  7. #SBATCH --job-name=lammps
  8.  
  9. ### Cola a usar (capacity, capability, gpu)
  10. #SBATCH --partition=gpu
  11.  
  12. ### Cantidad de nodos a usar
  13. #SBATCH --nodes=1
  14.  
  15. ### Cantidad de procesos a lanzar por nodo
  16. ### capacity=16, capability=18, gpu=20
  17. #SBATCH --ntasks-per-node=20
  18.  
  19. ### Cores por proceso
  20. ### LAMMPS está compilado con OpenMP, probar combinaciones
  21. #SBATCH --cpus-per-task=1
  22. export OMP_NUM_THREADS=1
  23. export MKL_NUM_THREADS=1
  24.  
  25. ### GPUs por nodo
  26. ### capacity/capability=0, gpu=1 (K20X) o 2 (M2090)
  27. #SBATCH --constraint=kepler
  28. #SBATCH --gres=gpu:1
  29.  
  30. ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  31. #SBATCH --time 7-0:00
  32.  
  33. ### Script que se ejecuta al arrancar el trabajo
  34.  
  35. ### Cargar el entorno del usuario incluyendo la funcionalidad de modules
  36. ### No tocar
  37. . /etc/profile
  38.  
  39. ### Cargar los módulos para la tarea
  40. # FALTA: Agregar los módulos necesarios
  41. module load md/lammps/15may15
  42.  
  43. ### Largar el programa con los cores detectados
  44. ### La cantidad de nodos y cores se detecta automáticamente
  45. # FALTA: agregar parámetros
  46. srun lmp_mendieta (...)
  47.  

  • Tarea: ejecutar programas utilizando los núcleos xeon PHI con MPI
  • Ejecución: sbatch submit.sh
  • Partición: phi
  • Tiempo máximo: 7 días

submit.sh
  1. #!/bin/bash
  2.  
  3. ### Las líneas #SBATCH configuran los recursos de la tarea
  4. ### (aunque parezcan estar comentadas)
  5.  
  6. ### Nombre de la tarea
  7. #SBATCH --job-name=test-phi-mpi
  8.  
  9. ### Cola a usar
  10. #SBATCH --partition=phi
  11.  
  12. ### No queremos compartir xeon phis, poca memoria
  13. #SBATCH --exclusive
  14.  
  15. ### Usar un xeon phi de 57 cores
  16. #SBATCH --nodes=1
  17. #SBATCH --ntasks-per-node=57
  18.  
  19. ### Cores por proceso (para MPI+OpenMP)
  20. #SBATCH --threads-per-core=4
  21.  
  22. ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  23. #SBATCH --time 7-0:00
  24.  

Makefile
  1. CC=mpiicc
  2. CFLAGS=-Wall -Wextra -O2 -mmic -openmp -mkl=parallel
  3.  
  4. TARGETS=proctest
  5.  
  6. proctest: proctest.o
  7. $(CC) $(CFLAGS) -o $@ $<
  8.  
  9. .PHONY: clean
  10.  
  11. clean:
  12. rm -f *.o $(TARGETS)
  13.  
  14.  

proctest.c
  1. #include <stdio.h>
  2. #include <omp.h>
  3.  
  4. #include "mpi.h"
  5.  
  6. int main(int argc, char ** argv) {
  7.  
  8. MPI_Init(&argc, &argv);
  9.  
  10. int commsize, commrank;
  11. MPI_Comm_size(MPI_COMM_WORLD, &commsize);
  12. MPI_Comm_rank(MPI_COMM_WORLD, &commrank);
  13.  
  14. #pragma omp parallel
  15. {
  16. int omptid = omp_get_thread_num();
  17. int ompthreads = omp_get_num_threads();
  18.  
  19. #pragma omp critical
  20. printf("MPI:%d/%d OMP:%d/%d\n", commrank, commsize, omptid, ompthreads);
  21. }
  22.  
  23. MPI_Finalize();
  24. return 0;
  25. }
  26.  
  27.  

  • Tarea: ejecutar programas utilizando los núcleos xeon PHI con OPENMP
  • Ejecución: sbatch submit_omp.sh
  • Partición: phi
  • Tiempo máximo: 7 días

submit_omp.sh
  1. #!/bin/bash
  2.  
  3. ### Las líneas #SBATCH configuran los recursos de la tarea
  4. ### (aunque parezcan estar comentadas)
  5.  
  6. ### Nombre de la tarea
  7. #SBATCH --job-name=test-phi-openmp
  8.  
  9. ### Cola a usar
  10. #SBATCH --partition=phi
  11.  
  12. ### No queremos compartir xeon phis, poca memoria
  13. #SBATCH --exclusive
  14.  
  15. ### Un solo proceso para OpenMP
  16. #SBATCH --ntasks=1
  17.  
  18. ### Cores por proceso
  19. #SBATCH --cpus-per-task=57
  20. #SBATCH --threads-per-core=4
  21.  
  22. ### Tiempo de ejecucion. Formato dias-horas:minutos. Maximo una semana.
  23. #SBATCH --time 7-0:00
  24.  
  25. ### Script que se ejecuta al arrancar el trabajo
  26.  
  27. ### Cargar el entorno del usuario
  28. ### (en phi: MKL e Intel MPI)
  29. ### No tocar
  30. . /etc/profile
  31.  
  32. ### No tenemos módulos en los xeon phi
  33. ### Hasta 4 hilos por core
  34. export OMP_NUM_THREADS=228
  35. export MKL_NUM_THREADS=228
  36.  
  37. ### Largar el programa
  38. srun ./proctest
  39.  

Makefile
  1. CC=icc
  2. CFLAGS=-Wall -Wextra -O2 -mmic -openmp -mkl=parallel
  3.  
  4. TARGETS=proctest
  5.  
  6. proctest: proctest.o
  7. $(CC) $(CFLAGS) -o $@ $<
  8.  
  9. .PHONY: clean
  10.  
  11. clean:
  12. rm -f *.o $(TARGETS)
  13.  

proctest.c
  1. #include <stdio.h>
  2. #include <omp.h>
  3.  
  4. int main(int argc, char ** argv) {
  5.  
  6. #pragma omp parallel
  7. {
  8. int omptid = omp_get_thread_num();
  9. int ompthreads = omp_get_num_threads();
  10.  
  11. #pragma omp critical
  12. printf("OMP:%d/%d\n", omptid, ompthreads);
  13. }
  14.  
  15. return 0;
  16. }
  17.  
  18.  
  19.  



wiki/tutorial_slurm.txt · Last modified: 2019/01/02 14:59 by dgrana