|
| |
|
|
¿Cómo correr un job de 15 días vía la cola de tres días?
Lo primero es comenzar a generar salidas intermedias en los cálculos. Luego usar la salida de un cálculo como entrada de otro cálculo. Una vez que pudimos segmentar el computo preparamos los scripts correspondientes.
Supongamos que llamamos a los script: script1, script2, script3, script4, script5. El script2 usa como entrada los datos que arrojo el script1, el sccript3 los del 2 y así sucesivamente. Lo que hay que hacer es ecolar el script2 luego de que el script1 haya terminado; el 3 luego del 2, etc.
Para no estar al pendiente de la finalización de un script para lanzar otro podemos tratar de lanzar los job de forma automática.
Hay varias formas de hacerlo, les dejamos algunos ejemplos que pueden adpatar a sus necesidades.
El siguiente ejemplo encola el script2 con un delay de 3 días desde el momento en que el script1 comienza a correr.
##################################
###Este es el script1
### --AQUÍ LAS OPCIONES DEL QSUB
###############################
## Obtener la fecha actual y sumarle 3 días
fecha=/share/apps/scripts/calcular_fecha
ssh hpc-cluster qsub -wd directorio_de_trabajo -a $fecha script2
#################################
##---AQUI LOS COMANDOS PARA REALIZAR EL CÁLCULO
La línea ssh hpc-cluster qsub -wd directorio_de_trabajo -a $fecha script el job a la cola con qsub desde el frontend y vuelve, es necesario especificar el directorio de trabajo con -wd porque de lo contrario se estaría llamando al script2 desde el home.
La opción -a es una opción del qsub que deja el job en cola pero será atendido hasta que se cumpla la fecha que se indicó; mientras tanto su prioridad es 0 y no entra a correr. Para más información ver el manual (man qusb)
/share/apps/scripts/calcular_fecha es un script de acceso público que les devuelve la fecha + 3 días en el formato que requiere el qsub. Se recomienda revisarlo antes de usarlo.
|
Enviar a correr un job, después que terminó de ejecutarse cierto cálculo de forma automática
El sisguiente ejemplo fue facilitado por H. Fabio Fusnengo. Trabaja de la siguiente manera: se dividen el cáculo en partes y se prepara cada entrada del programa de forma tal que el cálculo no involucre más de 6 horas; al finalizar la ejecucián del programa se evalúa si el cálculo convergió o si hay que seguir ejecutando otra parte a continuación
#$ -N Vasp-parallel
#
#$ -pe impi8 8
## Seting the maximum run time: setea 6 horas de wall clock time
#$ -l h_rt=6:00:00
## cambio a mi home
#$ -cwd
# MPIR_HOME, importo variables de entorno del SGE
#$ -V
#$ -v MPIR_HOME=/opt/intel/impi/3.1/bin64,SGE_QMASTER_PORT
echo "Got $NSLOTS slots."
PATH="/opt/intel/impi/3.1/bin64:$PATH" ; export path
exe="/opt/vasp/vasp.4.6/vasp-parallel"; export exe
#######esto es para control#######
echo $TMPDIR/machines
echo "host"
echo $NHOSTS
##################################
# Ejecución SIN opciones de debug de MPI
$MPIR_HOME/mpirun -machinefile $TMPDIR/machines -l -genv I_MPI_DEVICE sock -n $NSLOTS $exe
##################################################################
# Este bloque es donde se implementa el calculo recursivo usando como flag (para decidir si para
# o sigue) el numero de iteraciones ionicas del calculo anterior (niter=1 => el cálculo finalmente termino).
#
niter=`grep -c E0 OSZICAR`
echo $niter
if [ $niter != 1 ]
then
mkdir ./dir
cp ./CONTCAR ./dir/POSCAR
cp ./POTCAR ./dir/
cp ./INCAR ./dir/
cp ./KPOINTS ./dir/
cp vasp-parallel-recursivo.sh ./dir
cd ./dir
WDIR=`pwd`
echo $WDIR
ssh hpc-cluster qsub -wd $WDIR $WDIR/vasp-parallel-recursivo.sh
fi
################################################################
exit 0
|
Encolar trabajos
Lo básico
El script SGE más básico consiste en un conjunto de comandos, por ejemplo:
#!/bin/bash
#
hostname -f
date
Si nombramos al script con el nombre script1, luego lo enviamos a correr con el siguiente comando:
qsub script1
El script anteiror no seteaba ninguna opción del SGE. Si se necesita incluir opciones, estas deben agregarse en líneas que comiencen con #$
|
|
Los parámetros más usados son:
- -cwd Cambiar al directorio desde donde se a envÃado el script
- -N name name será el nombre del job
- -l recurso Solicita el recurso especificado. El ejemplo más comun es requirimiento de tiempo, por ejemplo -l h_rt=05:00:00 solicitará 5 horas de wall clock.
- -j y Stdout y stderr en el mismo archivo de salida
- -V Importa las variabeles entorno actuales dentro del script
- -S /bin/bash Usar el shell bash
- -pe entorno_paralelo slots Solicita slot slot en el entorno paralelo entorno_paralelo. Por ejemplo -pe mpich 4, solicita 4 slot en el entorno mpich
- -o archivo Archivo de salida
- -e archivo Archivo de salida en caso de error
- -t min-max Corre un arreglo de jobs desde el indice min al indice max
|
|
Trabajos series
El siguiente es un ejemplo con algunas opciones SGE.
#!/bin/bash
#
# Script para correr trabajo serial
#
# Opciones SGE
#$ -l h_rt=168:00:00 # Setea 168 horas de wall clock time
#$ -cwd # Cambia al directorio actual
#$ -V # Exporta las variables de entorno
#$ -N nombre_job # El nombre del job
# Comanndo para correr el programa, tal cual lo llamaríamos desde la línea de comandos
programa
Ejemplo de script para corrida paralela com MPI:
#$ -N nombre
#$ -pe impi 32
#$ -cwd
#$ -l h_rt=10:00:00
# MPIR_HOME, importo variables de entorno del SGE
#$ -V
#$ -v MPIR_HOME=/opt/intel/impi/3.1/bin64,SGE_QMASTER_PORT
PATH="/opt/intel/impi/3.1/bin64:$PATH" ; export path
$MPIR_HOME/mpirun -machinefile $TMPDIR/machines -l -genv I_MPI_DEVICE sock -n $NSLOTS ejecutable
|
Ejemplo de script para corrida paralela com OpenMp:
#$ -N nombre
#
#$ -pe openmp 8
#$ -l h_rt=10:00:00
#$ -cwd
# MPIR_HOME, importo variables de entorno del SGE
#$ -V
##Seteo la cantidad de threads que se va a usar
#$ -v OMP_NUM_THREADS=1 ### Setea la cantidad de threads a 1
# Comandos del usuario
Array de jobs
Los arreglos de job proveen un mecanismo para enviar un conjunto de jobs relacionados. A cada job se le asigna un ID de tarea que puede ser usado dentro del sript para controlar el comportamiento del job.
Los jobs son enviados como un bloque y controlados por un ID de job. Esta forma de enviar jobs es util cuando se intenta enviar a correr un mismo programa muchas veces con diferentes datos de entrada.
En vez de enviar cientos de jobs individuales, se puede enviar un único job que ejecute una tarea para cada input distinto.
Como ejemplo, consideremos la siguiente tarea. Tenemos 50 archivos con datos de entrada (datos.1 a datos.50) para un programa (serie), el script quedaría:
#!/bin/bash
#
# Script para correr array de jobs seriales
#
# Opciones SGE
#$ -l h_rt=10:00:00 # Setea 10 horas de wall clock time
#$ -cwd # Cambia al directorio actual
#$ -V # Exporta las variables de entorno
#$ -t 1-50 # Setea el array de indices
# corre el programa
$HOME/programa < datos.$SGE_TASK_ID > output.$SGE_TASK_ID
El SGE utilizará tantos slots como haya disponibles para correr tantas tareas en forma concurrente como sea posible.
También se pueden enviar arrays de jobs paralelos combinando las opciones t y pe.
|
|
Monitorización del trabajo:
- qstat: Muestra el estado de todos los trabajos sin tener en cuenta el estado de las colas.
- qstat -u nombre_usuario: Monitorización del estado de los trabajos de un usuario.
- qstat -f: Lista toda la información sobre trabajos y colas para todos los usuarios.
- qstat -F: Muestra el estado de todos los parámetros de todas las colas, por ejemplo, la carga, uso de memoria, swap, etc.
- qstat -j id_job : Da la razón de por qué un trabajo pendiente no ha sido planificado.
|
|
|
|