Ejemplo de uso

Es obligatorio especificar el tiempo máximo de ejecución con la opción –time=HH:MM:SS (o de forma reducida -t HH:MM:SS)

Ejemplos de envío de un trabajo al sistema de colas

Utilizando srun (no recomendable)

Las sesiones interactivas pueden ejecutarse dentro de un shell programado utilizando el comando srun. Por ejemplo:

$ srun -N2 -n2 -exclusive --time=00:00:10 hostname

Solicita dos servidores o nodos (N2) y envía dos tareas (n2) en modo exclusivo, (-exclusive) y ejecuta el
comando “hostname“, con un tiempo máximo de ejecución de 10 segundos. No se recomienda su uso ya
que bloquea el prompt hasta la ejecución completa del trabajo.

Utilizando sbatch

Generar un script job.sh con el siguiente contenido:

#!/bin/sh
#SBATCH -N 2 #(solicita dos nodos)
#SBATCH -n 2 #(dos tareas en total)
#SBATCH -p thinnodes #(solicita la partición específica. Pueden solicitarse varias separadas por comas)
#SBATCH -t 00:00:30 #(30 sec ejecución)
srun hostname

Y enviar el trabajo con el comando:

$ sbatch ./job.sh

Las opciones de sbatch se pueden cambiar en el momento del envío. Así, para enviar el script anterior a la
partición​ cola-corta ​ sin cambiar el script, se ejecutaría:

$ sbatch -p cola-corta ./job.sh

Envío de un trabajo OpenMP

1. Compilación:
   $ module load intel
$ ifort -qopenmp -o omphello_f omphello.f
$ icc -qopenmp -o omphello_c omphello.c
2. Script de ejecución en cola:
   $ cat run.sh
#!/bin/bash
#SBATCH -n 1 #(una tarea en total)
#SBATCH -c 8 #(8 cores por tarea)
#SBATCH -t 00:10:00 #(10 min ejecución)
srun ./omphello_f
3. Envío a cola
   $ sbatch run.sh

Envío de un trabajo OpenMP a la partición shared

1. Script de ejecución en cola:
   $ cat run.sh
#!/bin/bash
#SBATCH -n 1 #(una tarea en total)
#SBATCH -c 8 #(8 cores por tarea)
#SBATCH -t 00:10:00 #(10 min ejecución)
srun ./omphello_f
2. Envío a cola:
   $ sbatch run.sh

Envío de un trabajo MPI

1. Compilación del programa:
   $ module load intel impi
$ mpiifort -o pi3 pi3.f90
2. Script de ejecución en cola:
   $ cat run.sh
#!/bin/bash
#SBATCH -n 8
#SBATCH --ntasks-per-node=4
#SBATCH -c 2
#SBATCH -p thinnodes
#SBATCH -t 00:10:00
module load intel impi
srun ./pi3Se solicita la ejecución en 2 nodos, usando 8 procesos (-n 8) y 4 procesos por nodo (–ntasks-per-node=4)
   y dos cores por proceso (-c 2, en caso de que el programa pueda usar este tipo de paralelización híbrida.
   Ver la siguiente sección), en total 16 cores distribuidos en 8 por nodo.. Al solicitar más de un nodo es
   necesario especificar en qué partición debe ejecutarse (-p thinnodes) ya que la partición por defecto admite
   un uso máximo de 1 nodo.
   No es necesario cargar los módulos de las aplicaciones/compiladores/mpi dentro de los scripts de
   ejecución, basta con que estén cargados en el momento de envío a cola ya que el trabajo hereda el
   entorno del momento del envío. De hecho, por defecto, el directorio de trabajo será el directorio desde
   donde se envía el script.
3. Envío a cola:
   $ sbatch run.sh

Ejemplos de envíos para la ejecución usando 4 cores

Si se quieren reservar para una tarea ​4 cores para crear 4 threads​ :
$ sbatch -p shared --qos=shared -n 1 -c 4 script.sh
En caso de un ejemplo híbrido con OpenMP y MPI, en el cual se quiere reservar ​2 tareas de 2 cores
cada una en 2 nodos diferentes​ :
$ sbatch -p thinnodes -n2 --task-per-node=1 -c 2 script.sh
Se puede observar que se está especificando que se reserven 2 nodos y 2 tareas en total (procesos MPI),
que en cada nodo se ejecute una tarea y también que reserve dos cores por tarea.
En el caso de puro MPI donde cada tarea es ejecutada en un core, la reserva de ​4 cores (4 tareas) en 2
nodos diferentes​ sería:
$ sbatch -n 4 --task-per-node=2 -c 1 -p thinnodes script.sh

* en las particiones exclusivas sólo un único trabajo puede ejecutarse en un nodo. El nº de nodos son reservados completamente independientemente de los cores que se usen

Asignación de la memoria

El slurm por defecto reserva 5GB de memoria por cada core tanto en los nodos estándar como en el fat
node, pero en el caso de querer más memoria hay que especificarlo con las opciones ​ –mem ​ y
–mem-per-cpu ​ . En el caso de un trabajo que se vaya a ejecutar en un nodo en exclusiva, por defecto se
asigna toda la memoria del nodo (120GB en los nodos estándar).
A continuación se mostrarán uno cuantos ejemplos de la distribución de la memoria.
Se procede a enviar un trabajo que no necesita de paralelizar y se requiere de 6GB de memoria, se
especificaría de la siguiente forma:
$ sbatch -n 1 --mem=6GB script.sh
Si lo que queremos es más de un core para una tarea, y que cada core tenga 20GB de memoria habría
que hacer:
$ sbatch -n 1 --cpus-per-task=2 --mem-per-cpu=20GB script.sh