---
og:title: Ejecución de trabajos
---

# 🦺 Ejecución de trabajos

Para ejecutar programas se usa [SLURM](http://slurm.schedmd.com/),
que es un sistema de gestión de trabajos
utilizado en clusters para distribuir y gestionar tareas de manera eficiente.

Para correr un trabajo, se necesita crear un [script de lanzamiento](/tutoriales/slurm-script)
que describa los recursos requeridos por el trabajo y las tareas que realiza.
Más abajo encontrará [ejemplos de scripts](#ejemplos).


## Comandos básicos

- **sbatch**: Para encolar un trabajo cuyo submit script es `job.sh`,
  luego de encolar el trabajo le devolverá un número que lo identifica.

  ```console
  $ sbatch job.sh
  Submitted batch job 1234
  ```

- **squeue**: Muestra la cola de trabajos pendientes o en ejecución.

  ```console
  $ squeue --me
  ```

- **sinfo**: Proporciona información sobre el estado de los nodos en el cluster.

  ```console
  $ sinfo
  ```

- **scancel**: Para eliminar un trabajo de la cola o cancelar su ejecución,
  usando el identificador del trabajo.

  ```console
  $ scancel 1234
  ```


## Ver trabajos encolados

Para ver todos los trabajos pendientes y en ejecución, utilice `squeue`:

```{code-block} console
$ squeue
JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
55060     multi   script    alice PD       0:00      4 (Resources)
55079     multi   script    alice PD       0:00      1 (Priority)
55081     multi   script      bob PD       0:00      1 (AssocMaxJobsLimit)
55008     short   script      bob PD       0:00      1 (Dependency)
54915     multi   script    alice  R    1:27:18      4 rome[09,14,16,33]
55007     short   script      bob  R      30:58      1 rome05
```

Explicación:
* `JOBID`: El identificador.
* `PARTITION`: La partición en la que está.
* `NAME`: El nombre.
* `USER`: El usuario que lo encoló.
* `ST`: El estado, algunos estados comunes son:
  - `PD`: Pendiente (PENDING)
  - `R`: Ejecutandose (RUNNING)
  - `CG`: Finalizando (COMPLETING)
  - Para ver todos los estados posibles, [ver la documentación de SLURM](https://slurm.schedmd.com/job_state_codes.html).
* `TIME`: El tiempo que lleva ejecutando.
* `NODES`: La cantidad de nodos que se solicitaron.
* `NODELIST(REASON)`:  Los nodos en los que está corriendo el trabajo,
  o la razón por la que todavía no se está ejecutando.
  Algunas razones comunes son:
  - `(Resources)`: No hay recursos libres en el cluster para ejecutarlo.
  - `(Priority)`: Hay trabajos con mayor prioridad esperando a ser ejecutados.
  - `(AssocMaxJobsLimit)`: El usuario excede la cantidad de trabajos máxima en ejecución simultánea.
  - `(Dependency)`: El trabajo tiene dependencia sobre otro trabajo que aún no finalizó.
  - `(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.
  - `(Nodes required for job are DOWN, DRAINED or reserved)`: Si alguno de los nodos que están down se levanta este job lo ocuparía.
  - Para ver la lista completa, [ver la documentación de SLURM](https://slurm.schedmd.com/job_reason_codes.html).

## Ejemplos

### Hola Mundos

A continuación unos ejemplos básicos para probar y usar de base,
pero asegúrese de terminar de [configurar el resto de parametros](/tutoriales/slurm-script):

::::{tab-set}

:::{tab-item} 1 core
El script más simple posible: Corre en un sólo nodo,
lanza una sola task, que usa un sólo core
e imprime el nombre del nodo.
Funciona en cualquiera de los clusters.

```{code-block} slurm
:linenos:
:caption: job.sh
:name: hello-single-core
#!/bin/bash
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1

srun bash -c 'echo "Hola, me ejecuté en el nodo $SLURMD_NODENAME"'
```

```{admonition} Tarea
:class: hint
Pruebe cambiar `#SBATCH --nodes=1` por `#SBATCH --nodes=2`.
```
:::

:::{tab-item} Serafin
:sync: serafin

Acá vamos a pedir y aprovechar un 1 nodo completo de Serafín.

El siguiente script representa nuestro programa:

```{code-block} bash
:linenos:
:name: hello.sh
:caption: hello.sh
#!/bin/bash

echo $(date): En el nodo $SLURMD_NODENAME soy la task $SLURM_PROCID
sleep 5 # "calculos"
echo $(date): task $SLURM_PROCID terminó
```

Este es el script de lanzamiento para sbatch:

```{code-block} slurm
:linenos:
:name: hello-submit-serafin
:caption: job.sh
#!/bin/bash
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=64
#SBATCH --partition=short

srun hello.sh
```

Correrlo de la siguiente manera:

```{code-block} console
$ chmod +x hello.sh # solo una vez
$ sbatch job.sh
```

```{admonition} Tarea
:class: hint
Debe revisar los logs y ponga atención a los tiempos entre los dos `echo`s.

Pruebe cambiar `#SBATCH --nodes=1` por `#SBATCH --nodes=2`.
```

:::

:::{tab-item} Mendieta
:sync: mendieta

Pedir una GPU en Mendieta.

```{code-block} slurm
:linenos:
:name: hello-mendieta
:caption: job.sh
#!/bin/bash
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --partition=short
#SBATCH --gres=gpu:1

echo En el nodo $(hostname) tengo acceso a las siguientes GPUs:
nvidia-smi -L
```

:::

:::{tab-item} Eulogia
:sync: eulogia

Preámbulo para 2 nodos completos:

```{code-block} slurm
:name: hello-eulogia
:caption: job.sh
:linenos:
#!/bin/bash
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=64
#SBATCH --cpus-per-task=4
```
:::

:::{tab-item} Mulatona
:sync: mulatona

Preámbulo para 1 nodo completo:

```{code-block} slurm
:name: hello-mulatona
:caption: job.sh
:linenos:
#!/bin/bash
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=32
#SBATCH --cpus-per-task=1
```
:::

::::



%TODO: cambiar a la version 7.2 y verificar que si lo copian tal cual va a funcionar
### Quantum Espresso

::::{tab-set}
:::{tab-item} Serafín
:sync: serafin

```{code-block} slurm
:caption: job.sh
:name: qe-serafin
:linenos:
#!/bin/bash
#SBATCH --job-name=espresso
#SBATCH --partition=multi
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=64
#SBATCH --cpus-per-task=1

# Cargar el entorno del usuario incluyendo la funcionalidad de modules
# No tocar
. /etc/profile

# Configurar OpenMP y otras bibliotecas que usan threads
# usando los valores especificados arriba
export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
export MKL_NUM_THREADS=$SLURM_CPUS_PER_TASK

# Cargar los módulos para la tarea
module load quantum-espresso/7.2

# Lanzar el programa
srun pw.x -nk 1 -inp input > output
```
:::

:::{tab-item} Eulogia
:sync: eulogia

```{code-block} slurm
:caption: job.sh
:name: qe-eulogia
:linenos:
#!/bin/bash
#SBATCH --job-name=espresso
#SBATCH --partition=multi
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=64
#SBATCH --cpus-per-task=1

. /etc/profile

# Configurar OpenMP y otras bibliotecas que usan threads
# usando los valores especificados arriba
export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK
export MKL_NUM_THREADS=$SLURM_CPUS_PER_TASK

# Cargar los módulos para la tarea
module load quantum-espresso/7.1

# Lanzar el programa
srun pw.x -nk 1 -inp input > output
```
:::

::::

### GROMACS

::::{tab-set}

:::{tab-item} Serafín
:sync: serafin
```{code-block} slurm
:caption: job.sh
:name: gromacs-serafin
:linenos:
#!/bin/bash
#SBATCH --job-name=gmx
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=64
#SBATCH --partition=multi

. /etc/profile
module load gromacs
srun gmx_mpi mdrun -ntomp ${SLURM_CPUS_PER_TASK} (...)
```
:::

:::{tab-item} Mendieta
:sync: mendieta
```{code-block} slurm
:caption: job.sh
:name: gromacs-mendieta
:linenos:
#!/bin/bash
#SBATCH --job-name=gmx
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=10
#SBATCH --gpus-per-task=1
#SBATCH --partition=multi
#SBATCH --gres=gpu:1

. /etc/profile
module load gromacs
srun gmx_mpi mdrun -nb gpu -pme gpu -bonded gpu -update gpu -ntomp ${SLURM_CPUS_PER_TASK} (...)
```
:::

:::{tab-item} Eulogia
:sync: eulogia
```{code-block} slurm
:caption: job.sh
:name: gromacs-eulogia
:linenos:
#!/bin/bash
#SBATCH --job-name=gmx
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=64
#SBATCH --partition=multi

. /etc/profile
module load gromacs
srun gmx_mpi mdrun -ntomp ${SLURM_CPUS_PER_TASK} (...)
```
:::

::::


### Sesión interactiva

Se puede reservar un nodo y ejecutar comandos interactivamente
::::{tab-set}

:::{tab-item} Sin GPU
```{code-block} console
$ srun --pty bash
```
:::

:::{tab-item} Con GPU
```{code-block} console
:caption: Sólo en Mendieta!
$ srun --gres=gpu:1 --pty bash
```
:::

::::


## Otros comandos útiles

* **Validar un script sin ejecutarlo**
   ```console
   $ sbatch --test-only script.sh
   ```

   Este comando verifica si el script es válido y estima cuándo podría ejecutarse según los recursos solicitados, pero **no** lo pone en la cola.

* **Historial de trabajos del último mes**
  ```console
  $ sacct -X -S now-4weeks
  ```
  Muestra información detallada sobre trabajos pasados o en ejecución.

* **Consultar el uso de recursos**
   ```console
   $ sreport cluster AccountUtilizationByUser -t hours users=$USER start=2025-01-01 end=2026-01-01
   ```

* **Consultar información de un job**
  ```console
  $ scontrol show job $JOBID
  ```
  Donde la variable `$JOBID` debe ser reemplazada por el número del job.

  Con este comando es posible verificar que SLURM haya encolado el trabajo de acuerdo a lo solicitado en el preámbulo.