Archivo de la categoría: Mandar trabajos

Qsub interactivo

Mandar trabajos

Si se ejecuta simplemente qsub sin añadir ningúna orden más:

qsub

este entrará en modo interactivo, nos realizará unas preguntas simples, que nos guiará en el proceso para enviar varios tipos de trabajo de un modo sencillo. Se puede usar con cualquier ejecutable pero también hay una lista de programas predefinidos (vasp, wrf, adinit, gaussian, nwchem …) de los cuales además se realizan comprobaciones como que los ficheros necesarios están presentes. Si se quiere añadir alguno más a la lista contactar con lo técnicos. Las respuestas son almacenadas como respuestas por defecto para la siguiente vez.

De acuerdo a los parámetros definidos por el usuario, el sistema de colas encajará cada trabajo en la cola pertinente. En caso de que algun parametro no sea definido por el usuario, TORQUE tiene determinados unos por defecto, que pueden no adecuarse al trabajo que mandamos por lo que es muy recomendable definirlos.

Para poder seguir correctamente las preguntas del qsub interactivo, os recomendamos que reviseis el apartado otras directivas.

Qsub tradicional

Mandar trabajos

Ejecutar en la línea de comandos
qsub script_file

donde el archivo script_file contiene las directivas para el gestor de colas TORQUE y los comandos a ejecutar para poner el trabajo en marcha. En las siguientes secciones se detallan ciertos scripts. Una vez mandado el trabajo a la cola, obtendremos en pantalla el número de identificación del proceso, por ejemplo:

159.lgua00

Tras la ejecución, comprobar el contenido del archivo script.e159, en este caso para verificar los errores. La salida estándar del programa está en scrip.o159.

Trabajo en serie
En los trabajos en serie es altamente recomendable que se trabaje usando el espacio de disco local, la partición /scratch situada en cada nodo. El proceso de lectura y escritura es más rápido, por lo que el propio trabajo se ve beneficiado. Además, no se usa la red (NFS) en la lectura/escritura, por lo que el resto de los trabajos en otros nodos también irán más rápido y se evita saturar la red.

Los scripts se envían al sistema de colas con el comando

qsub script_file

o se puede usar el modo interactivo

qsub

Para seleccionar el tipo de arquitectura o nodo ver otras directivas.

Una plantilla de script que ejecuta el programa a.out es

#!/bin/bash
#PBS -l walltime=[val]
#PBS -l mem=[val]
#PBS -l nodes=1:ppn=1

#Nuestro directorio de scratch
scrt=/scratch/$USER/$PBS_JOBID

mkdir $scrt
#Copiamos los archivos al directorio scratch.
#Usaremos cp -r para copiar también subdirectorios.
cp $PBS_O_WORKDIR/* $scrt

#Nos movemos de directorio
cd $scrt

#Ejecutamos el programa
./a.out

#Movemos los archivos finales a nuestro home
outdir=escoger_nombre
mkdir $PBS_O_WORKDIR/$outdir
mv -f $scrt/* $PBS_O_WORKDIR/$outdir

#Borramos el directorio
rmdir $scrt

Las líneas que comienzan con #PBS son órdenes para el gestor de colas que seleccionan:

nodes: [opcional] Se puede usar para selecionar el nodo de cálculo (ejemplo: node=cn14).

mem: Memoria RAM reservada para el cálculo, medida en mb o gb (ejemplo: [val]=100mb).

walltime: Tiempo de microprocesador reservado en formato hh:mm:ss (ejemplo: [val]=24:00:00).

El resto de líneas que comienzan con # son comentarios.

En el script hay que sustituir escoger_nombre por el del directorio donde queremos guardar los resultados. La variable $USER devuelve el nombre del usuario, $PBS_O_WORKDIR el directorio de trabajo desde donde se ejecuta el comando qsub y $PBS_JOBID el número de identificación del trabajo.

Si el programa a.out no está en un directorio del $PATH, e.g. /usr/local/bin sino en nuestro directiorio es necesario usar ./a.out .

Ejemplo de trabajo en serie.

Tras la ejecución, comprobar el contenido del archivo script.eXXX para verificar los errores.

Las órdenes para PBS se pueden indicar directamente en el comando, en vez de en el script, usando a la hora de enviar el trabajo

qsub -l nodes=[name],mem=[val],walltime=[val] script

Trabajo en paralelo
Es recomendable lanzar los trabajos a 4 procesadores o 8 procesadores por nodo (ppn=4 o ppn=8), lo cual reduce los tiempos de espera. También es altamente recomendable que los trabajos escriban localmente en los nodos cuando sea posible.

Si el trabajo corre en un único nodo o, corriendo en más nodos, los microprocesadores no comparten archivos, el trabajo puede escribir sobre el disco local. Los scripts se envían al sistema de colas con el comando

qsub script_file

o se puede usar el modo interactivo

qsub

Para seleccionar el tipo de arquitectura o nodo ver otras directivas.

Una plantilla de script que ejecuta el programa a.out en paralelo es

#!/bin/bash
#PBS -l nodes=[val]:ppn=[val]
#PBS -l walltime=[val]
#PBS -l mem=[val]

#Nuestro directorio de scratch
scrt=/scratch/$USER/$PBS_JOBID

#Creamos el directorio
mkdir $scrt
#Copiamos los archivos al directorio scratch
#Usaremos cp -r $scrt para copiar también subdirectorios.
cp $PBS_O_WORKDIR/* $scrt

#Nos movemos de directorio
cd $scrt

#Ejecutamos el programa
mpirun a.out

#Movemos los archivos finales
outdir=escoger_nombre
mkdir $PBS_O_WORKDIR/$outdir
mv -f $scrt/* $PBS_O_WORKDIR/$outdir

#Borramos el directorio
rmdir $scrt

Las líneas que comienzan con #PBS son órdenes para el gestor de colas que seleccionan:

nodes: Número de nodos en los que se va a ejecutar el programa (ejemplo [val]=2).

ppn: Número de microprocesadores por nodo que va a usar el programa (ejemplo [val]=4).

mem: Memoria RAM reservada para el cálculo, medida en mb o gb (ejemplo: [val]=100mb).

walltime: Tiempo de microprocesador reservado en formato hh:mm:ss (ejemplo: [val]=24:00:00).

En el script hay que sustituir escoger_nombre por el del directorio donde queremos guardar los resultados la variable $USER devuelve el nombre del usuario, $PBS_O_WORKDIR el directorio de trabajo desde donde se ejecuta el comando qsub y $PBS_JOBID el número de identificación del trabajo.

Ejemplo de trabajo en paralelo usando el disco local /scratch .

Si el trabajo va a correr en varios nodos y los procesos comparten archivos han de ejecutarse desde nuestro /gscratch, que es un sistema de archivos de alto rendimiento compartido por todos los nodos (ver coniguración). El script que realiza esto es

#!/bin/bash
#PBS -l nodes=[val]:ppn=[val]
#PBS -l walltime=[val]
#PBS -l mem=[val]

#Nuestro directorio de scratch
scrt=/gscratch/$USER/$PBS_JOBID

#Creamos el directorio
mkdir $scrt
#Copiamos los archivos al directorio scratch
#Usaremos cp -r $scrt para copiar también subdirectorios.
cp $PBS_O_WORKDIR/* $scrt

#Nos movemos de directorio
cd $scrt

#Ejecutamos el programa
mpirun a.out

#Movemos los archivos finales
outdir=escoger_nombre
mkdir $PBS_O_WORKDIR/$outdir
mv -f $scrt/* $PBS_O_WORKDIR/$outdir

#Borramos el directorio
rmdir $scrt

Ejemplo de trabajo en paralelo usando gscratch.

Tras la ejecución, comprobar el contenido del archivo script.eXXX para verificar los errores.

Las órdenes para PBS se pueden indicar directamente en el comando, en vez de en el script, usando a la hora de enviar el trabajo

qsub -l nodes=[val]:ppn=[val],mem=[val],cput=[val] script

Cómo mandar NWchem

F.A.Q., Mandar trabajos

send_nwchem

Para lanzar al sistema de colas Nwchem existe la utilidad send_nwchem. Al ejecutarlo, muestra la sintaxis del comando, que se resume a continuación:

send_nwchem JOBNAME PROCS[property] TIME MEM [``Otherqueue options'' ]

  • JOBNAME: Nombre del input de nwchem sin extensión.
  • PROCS: Número de procesadores.
  • TIME: Tiempo solicitado a la cola, formato hh:mm:ss.
  • MEM: memoria en GB y sin especificar la unidad.
  • [«Otras opciones de Torque»] Existe la posibilidad de pasar más variables al sistema de colas. Ver ejemplos más abajo. Más información sobre estas opciones

Ejemplos

Mandamos NWchem con el input job1 a 1 nodo, 4 procesadores de ese nodo tipo itaniumb, con un tiempo solicitado de 4 horas y 1 GB de RAM:

send_nwchem job1 4:itaniumb 04:00:00 1

Mandamos NWchem con el input job2 a 2 nodos, 8 procesadores en cada nodo, con un tiempo solicitado de 192 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arina:

send_nwchem job2 16 192:00:00 8 ``-W depend=afterany:1234''

Mandamos NWchem con el input job3 a 4 nodos y 8 procesadores en cada nodo, con un tiempo solicitado de 200:00:00 horas, 2 GB de RAM y que nos envíe un mensaje de correo al inicio y final del cálculo a la dirección especificada.

send_nwchem job3 32 200:00:00 2 ``-m be -M mi.email@ehu.es''

El comando send_nwchem copia el contenido del directorio desde el que se lanza al /scratch o /gscratch -si se usan 2 o más nodos. Es allí donde realiza el cálculo.

qsub interactivo

Ejecutando

qsub

entramos en el modo [intlink id=»233″ type=»post»]qsub en interactivo[/intlink] y nos hace varias preguntas para preparar el trabajo, uno de los programas para los que está preparado es NWchem.

Monitorización de los cálculos

Para facilitar el seguimiento y/o control de los cálculos, existen las suiguientes herramientas (sólo si ha sido enviado usando send_nwchem o qsub interactivo):

  • remote_vi: Nos enseña con el editor gvim el *.out del cálculo de nwchem.
  • remote_molden: Nos enseña con el molden el *.out del cálculo de nwchem.
  • remote_xmakemol: Para dimámicas. Nos enseña con el xmakemol el *.md.xyz del cálculo de nwchem.
  • remote_qmde: Nos enseña con el xmgrace la evolución de la energía respecto al tiempo de un cálculo de Dinámica Molecular.

El uso de todas estar herramientas es muy similar, hay que ejecutarlas seguido el identificador que el cálculo tiene en el sistema de colas.

Ejemplos

remote_vi 1243.arina
remote_xmakemol 2390.arina
remote_molden 2390.arina
remote_qmde 3432.arina

ECCE

ECCE 4.0.2 (Extensible Computational Chemistry Environment) es una aplicación desarrollada por el mismo grupo que Nwchem (ECCE Homepage). Dispone de una interface grafica que permite preparar inputs para nwchem, gaussian, y otros programas de química cuántica. Para su uso simplemente hay que ejecutar:

ecce &

Os recomendamos ejecutar ECCE en maiz y usando Nomachine NX.

Más información

Manual en línea de NwChem.

~

Cómo mandar Gaussian

F.A.Q., Mandar trabajos

Comando send_gauss

El comando send_gauss envía los cálculos con g09.

Recomendamos el uso del comando send_gauss. Este comando preparará script de TORQUE y lo enviará a la cola. El fichero de log (*.log) se mantendrá en el /scratch del nodo de remoto, pero send_gauss envía el trabajo de tal menera que puede ser visualizado con las herramientas remote_vi y remote_molden (ver más abajo).

modo de uso del comando send_gauss es el siguiente:

send_gauss trabajo cola_o_tiempo num_proc [mem] [opciones de TORQUE]

donde:

  • trabajo: Es el nombre del input de gaussian sin la extensión (*.com).
  • cola o tiempo: Se puede indicar la cola a la que se quiere mandar el cálculo o el tiempo en formato (hh:mm:ss).
  • num_proc: El número de procesadores que se quiere usar por nodo, ha de ser igual o menor de 8 o un múltiplo de 8. Es posible añadir propiedades de los nodos, por ejemplo 8:itaniumb
  • mem:  la memoria en GB.
  • [opciones de TORQUE]: Opciones avanzadas que se quieren pasar al gestor de colas TORQUE.

Ejemplos

send_gauss h2o p_slow 8

Enviará el trabajo h2o en  1 nodo y 8 procesadores a la cola p_slow con los valores de memoria predeterminados en este caso 7.2Gb (nproc*900mb).

send_gauss h2o p_slow 16 20

Enviará el trabajo h2o en dos nodos y 8 procesadoresencada uno  a la cola p_slow con 20gb de memoria RAM.

send_gauss h2o 23:00:00 16:xeon 4 ``-m be -M niri@ehu.es -W depend=afterany:4827''

Enviará el trabajo h2o en 2 nodos Xeony 8 procesadoeres en cada uno,  con 4gb de RAM. El tiempo solicitado son 23 horas, y nos enviará un email al inicio y final del cálculo. Por otra parte este trabajo no empezará hasta que termine el trabajo 4827.

Comando qsub interactivo

Si se ejecuta simplemente qsub sin añadir ninguna orden más:

qsub

este entrará en modo interactivo, nos realizará unas preguntas simples, que nos guiará en el proceso para enviar varios tipos de trabajo de un modo sencillo. Más informacián en [intlink id=»233″ type=»post»]qsub interactivo[/intlink].

qsub tradicional

Podemos construir nuestro propio script para Torque. [intlink id=»237″ type=»post» target=»_blank»]En este enlace[/intlink] hay ejemplos adecuados.

Seguimiento del trabajo

Existen las herramietas remote_vi y remote_molden, que permiten ver el fichero .log o mostrar la estructura con Molden. Para ello hay que usar send_gaussian o qsub interactivo. Su uso el el siguiente:

remote_vi 2341
remote_molden 2341

o

remote_vi 2341.arina
remote_molden 2341.arina

donde 2341(.arina) es el identificador del trabajo en la cola.

Como Mandar Wien2k

F.A.Q., Mandar trabajos

Wien2k requiere de un fichero especial. Los scripts se envían al sistema de colas con el comando

qsub script_file

script_wien de script que ejecuta el programa run_lapw en paralelo es

#!/bin/bash
#PBS -l nodes=[val]:ppn=[val]
#PBS -l walltime=[val]
#PBS -l mem=[val]

# Vamos a nuestro home
cd $PBS_O_WORKDIR

#Creamos el fichero .machines
cat $PBS_NODEFILE |cut -c1-6 >.machines_current
aa=$(wc -l .machines_current |cut -d " " -f 1)
echo '#' > .machines

i=1
while [ $i -le $aa ];do
echo -n '1:' >>.machines
head -$i .machines_current |tail -1 >> .machines
let i=i+1
done
echo 'granularity:1' >>.machines
echo 'extrafine:1' >>.machines

#Nuestro directorio de scratch
scrt=/scratch/$USER/$(echo $PBS_O_WORKDIR |xargs basename)
outdir=bukatuta_$PBS_JOBID
export SCRATCH=$scrt/scratch

#Creamos el directorio
mkdir $scrt
mkdir $scrt/scratch

#Copiamos los archivos al directorio scratch
#Usaremos cp -r $scrt para copiar también subdirectorios.
cp $PBS_O_WORKDIR/* $scrt
cp .machines $scrt

#Nos movemos de directorio
cd $scrt

#Ejecutamos WIEN2k en paralelo
run_lapw -p
#Movemos los archivos finales
mkdir  $PBS_O_WORKDIR/$outdir
mv -f $scrt/* $PBS_O_WORKDIR/$outdir
mv -f $scrt/.machines $PBS_O_WORKDIR/$outdir

#Borramos el directorio
rmdir $scrt
rm .??*

Las líneas que comienzan con #PBS son órdenes para el gestor de colas que seleccionan:

nodes: Número de nodos en los que se va a ejecutar el programa (ejemplo [val]=2).

ppn: Número de microprocesadores por nodo que va a usar el programa (ejemplo [val]=4).

mem: Memoria RAM reservada para el cálculo, medida en mb o gb (ejemplo: [val]=100mb).

walltime: Tiempo de microprocesador reservado en formato hh:mm:ss (ejemplo: [val]=24:00:00).

En el script la variable $USER devuelve el nombre del usuario, $PBS_O_WORKDIR el directorio de trabajo desde donde se ejecuta el comando qsub y $PBS_JOBID el número de identificación del trabajo.

Cómo mandar Qsite

F.A.Q., Mandar trabajos

send_qsite

send_qsite JOBNAME DONES PROCS_PER_NODE[property] TIME MEM [``Other queue options'']

  • JOBNAME: Nombre del input de siesta sin extensión.
  • NODES: Número de nodos.
  • PROCS: Número de procesadores.
  • TIME: Tiempo solicitado a la cola, formato hh:mm:ss.
  • MEM: memoria en Gb y sin especificar la unidad.
  • [«Other queue options»] Existe la posibilidad de pasar más variables al sistema de colas. Más información sobre estas opciones

Ejemplos:
Mandamos Jaguar con el input job1 a 1 nodo, 4 procesadores de ese nodo tipo itaniumb, con un tiempo solicitado de 4 horas y 1 GB de RAM:

  • send_qsite job1 1 4:itaniumb 04:00:00 1

Mandamos qsite con el input job3 a 2 nodos, 4 procesadores en cada nodo, con un tiempo solicitado de 60 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arinab:

  • send_qsite job3 2 4 60:00:00 8 ``-W depend=afterany:1234''

Mandamos qsite con el input job3 a 1 nodos y 4 procesadores en cada nodo, con un tiempo solicitado de 500 horas, 15 GB de RAM y que nos envíe un email al inicio y final del cálculo a la direción especificada.

  • send_qsite job3 1 4 400:00:00 15 ``-m be -M mi.email@ehu.es''

qsub interactivo

qsub

y seguir la instruciones.
La versión de QSITE disponible es la 5. Los manuales están disponibles en arina:/software/schrodinger/docs.

Cómo mandar Turbomole

Mandar trabajos

send_turbo

Para lanzar al sistema de colas trabajos de Turbomole existe la utilidad send_turbo. Al ejecutarlo, muestra la sintaxis del comando, que se resume a continuación:

send_turbo "EXEC and Options" JOBNAME TIME[or QUEUE] PROCS[property]  MEM [``Otherqueue options'' ]

  • EXEC: Nombre del programa de turbomole que se quiere usar.
  • JOBNAME: Nombre del input (normalmente control).
  • PROCS: Número de procesadores.
  • TIME[or QUEUE]: Tiempo solicitado a la cola, formato hh:mm:ss (o nombre de la cola).
  • MEM: memoria en GB y sin especificar la unidad.
  • [«Otras opciones de Torque»] Existe la posibilidad de pasar más variables al sistema de colas. Ver ejemplos más abajo. Más información sobre estas opciones

Ejemplos

Para mandar Turbomole (binario jobex) con el input control a 1 nodo, 8 procesadores de ese nodo con un tiempo solicitado de 4 horas y 1 GB de RAM ejecutar:

send_turbo jobex control 04:00:00 8 1

Para mandar Turbomole (jobex -ri) con el input control a 2 nodos, 8 procesadores en cada nodo, con un tiempo solicitado de 192 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arina:

send_turbo jobex -ri control 192:00:00 16 8 ``-W depend=afterany:1234''

El comando send_turbo copia el contenido del directorio desde el que se lanza al /scratch o /gscratch -si se usan 2 o más nodos, es allí donde realiza el cálculo.

Como Mandar Gamess

F.A.Q., Mandar trabajos

Información General

Gamess es un paquete de química computacional con varios métodos para calcular propidedades de sistemas moleculares, usando descripciones mecanico-cuánticas estandar para las funciones de onda o la densidad electrónica. La versión 12 JAN 2009 (R1) se encuentra instalada en el cluster. En estos momentos, se podran ejecutar los trabajos de gamess en vários nodos, con 8 o más procesadores.

Comando send_gamess

Para mandar trabajos de gamess a la cola, recomendamos el uso del comando send_gamess. Este comando preparará script de TORQUE y lo enviará a la cola. El el *.log se mantendrá en el /scratch del nodo de remoto.

Modo de Uso del comando send_gamess :

send_gamess trabajo num_nodos num_proc tiempo MEM (opciones del TORQUE)

donde:

trabajo: es el nombre del input de gamess sin la extensión (*.com).
cola o tiempo: se puede indicar la cola a la que se quiere mandar el cálculo o el tiempo en formato (hh:mm:ss).
num_nodos: el número de nodos que se quiere usar.
num_proc: el número de procesadores que se quiere usar. Máximo 8. Es posible añadir propiedades de los nodos, por ejemplo 8:itaniumb
mem: La memoria en Gb. Si no se especifica, el valor por defecto es nproc*900mb.
(opciones del TORQUE) Opciones avanzadas que se quieren pasar al gestros de colas TORQUE. [intlink id=»244″ type=»post»]Más información sobre estas opciones[/intlink]

Ejemplos:

send_gamess ti3_cor 1 8 90:00:00 4

Enviará el trabajo ti3_cor en 1 nodo, con 8 procesadores, 90 horas de duración y 4Gb de memoria RAM.

send_gamess ti3_cor 4 8 190:00:00 16
Enviará el trabajo ti3_cor en 4 nodos, y 8 procs en cada nodo, solicitando 190 horas y 16gb de memoria RAM.

send_gamess ti3_cor 4 4:itanium4 23:00:00 4 ``-m be -M niris@ehu.es -W depend=afterany:4827''

Enviará el trabajo ti3_cor en 4 nodos con 4 procesadoeres que tengan la propiedad itanium4, 4gb de RAM. El tiempo solicitado son 23 horas, y nos enviará un email al inicio y final del cálculo. Por otra parte este trabajo no empezará hasta que termine el trabajo 4827.

Seguimiento del Cálculo

Para poder visualizarlo, tenemos disponibles las herramientas

Para relaizar el seguimiento del trabajo existen las herramietas remote_vi y remote_molden. Su uso el el siguiente:

remote_vi 2341
o
remote_vi 2341.arinab

donde 2341(/.arinab) es el identificador del trabajo en la cola.

qsub interactivo

También se puede lanzar gamess con el comando [intlink id=»233″ type=»post»]qsub interactivo[/intlink].

Cómo mandar Terachem

F.A.Q., Mandar trabajos

Introducción

A parte de los scripts normales de Torque que se pueden escribir existe el comando send_terachem que facilita enviar los trabajos al sistema de colas.

send_terachem

Para mandar [intlink id=»3849″ type=»post»]Terachem[/intlink] se ha definido el comando send_terachem:

send_terachem JOBNAME TIME MEM [``Other queue options'']

donde

JOBNAME: Nombre del input de Terachem sin extensión.
TIME: Tiempo solicitado a la cola, formato hh:mm:ss.
MEM: memoria en Gb y sin especificar la unidad.
[``Other queue options''] Existe la posibilidad de pasar más variables al sistema de colas.

Ejemplos

  • Mandamos Terachem con el input job1 con un tiempo solicitado de 4 horas y 1 GB de RAM.
send_terachem job1 04:00:00 1
  • Mandamos jaguar con el input job2, con un tiempo solicitado de 60 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arina.
send_terachem job3 60:00:00 8 ``-W depend=afterany:1234''
  • Mandamos jaguar con el input job3, con un tiempo solicitado de 500 horas, 15 GB de RAM y que nos envíe un email al inicio y final del cálculo a la direción especificada.
send_terachem job3 400:00:00 15 ``-m be -M mi.email@ehu.es''

Como Mandar Jaguar

F.A.Q., Mandar trabajos

Comando send_jaguar

Para mandar Jaguar se ha definido el comando send_jaguar:

send_jaguar JOBNAME NODES PROCS_PER_NODE TIME MEM [``Other queue options'']

donde

JOBNAME: Nombre del input de siesta sin extensión.
NODES: Número de nodos.
PROCS: Número de procesadores.
TIME: Tiempo solicitado a la cola, formato hh:mm:ss.
MEM: memoria en Gb y sin especificar la unidad.
[``Other queue options''] Existe la posibilidad de pasar más variables al sistema de colas. Más información sobre estas opciones

Ejemplos

  • Mandamos Jaguar con el input job1 a 1 nodo, 8 procesadores de ese nodo tipo itaniumb, con un tiempo solicitado de 4 horas y 1 GB de RAM.
send_jaguar job1 1 8:itaniumb 04:00:00 1
  • Mandamos jaguar con el input job3 a 2 nodos, 4 procesadores en cada nodo, con un tiempo solicitado de 60 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arinab.
send_jaguar job3 2 4 60:00:00 8 ``-W depend=afterany:1234''
  • Mandamos jaguar con el input job3 a 1 nodos y 8 procesadores en cada nodo, con un tiempo solicitado de 500 horas, 15 GB de RAM y que nos envíe un email al inicio y final del cálculo a la direción especificada.
send_jaguar job3 1 8 400:00:00 15 ``-m be -M mi.email@ehu.es''

Qsub interactivo

También se pueden enviar los cálculos con el [intlink id=»233″ type=»post»]qsub interactivo.[/intlink]

Cómo mandar trabajos de Siesta

F.A.Q., Mandar trabajos

Cómo mandar trabajos de siesta

Existen 3 posibilidades.

  1. Con el comando send-siesta.
  2. Con el comando qsub en interactivo.
  3. Con un scrtip tradicional para qsub.

Comando send_siesta

Si se ejecuta send_siesta muestra una ayuda de como ejecutarse. El modo de mso del comando send_siesta es el siguiente:

send_siesta JOBNAME NODES PROCS_PER_NODE[property] TIME MEM [``Other queue options'']

JOBNAME: Nombre del input de siesta sin extensión.
NODES: Número de nodos.
PROCS: Número de procesadores por nodo.
TIME: Tiempo solicitado a la cola, formato hh:mm:ss.
MEM: memoria en Gb y sin especificar la unidad.
[``Other queue options''] Existe la posibilidad de pasar más variables al sistema de colas. Más información sobre estas opciones

El comando send_siesta o qsub interactivo copia el contenido del directorio desde el que se lanza al /scratch o /gscratch -si se usan 2 o más nodos-. Y es allí donde realiza el cálculo.

Ejemplos

Mandamos Siesta con el input job1.fdf a 1 nodo, 4 procesadores de ese nodo tipo itaniumb, con un tiempo solicitado de 4 horas y 1 GB de RAM:

send_siesta job1 1 4:itaniumb 04:00:00 1

Mandamos Siesta con el input job3.fdf a 2 nodos, 4 procesadores en cada nodo, con un tiempo solicitado de 60 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arinab:

send_siesta job3 2 4 60:00:00 8 ``-W depend=afterany:1234''

Mandamos Siesta con el input job3.fdf a 1 nodo y 4 procesadores en cada nodo, con un tiempo solicitado de 400 horas, 15 GB de RAM y que nos envíe un email al inicio y final del cálculo a la direción especificada.

send_siesta job3 1 4 400:00:00 15 ``-m be -M mi.email@ehu.es''

 

qsub interactivo

Ejecutamos

 qsub

sin argumentos y respondemos a las preguntas.

qsub tradicional

También existe la posibilidad de mandar siesta de la forma clásica, donde el usuario se créa su script de PBS. Hay ejemplos en este link. Hay que añadir al script la orden:

/software/bin/siesta/siesta_mpi < input.fdf > log.out

Monitorización de los cálculos

Para facilitar el seguimiento y/o control de los cálculos, existen las suiguientes herramientas si ha sido enviado usando send_siesta o qsub en interactivo:

  • remote_vi Nos enseña con el gvim el *.out del cálculo de siesta.
  • remote_xmakemol Nos enseña con el xmakemol el *.ANI del cálculo de siesta.
  • remote_qmde Nos enseña con el xmgrace la evolución de la energía respecto al tiempo de un cálculo de Dinámica Molecular .

El uso de todas estas herramientas es muy similar, hay que ejecutarlas seguido el identificador que el cálculo tiene en el sistema de colas. Ejemplos para monitorizar el trabajo con identificador 3465:

remote_vi 3465
remote_xmakemol 3465
remote_qmde 3465

Cómo enviar Orca

F.A.Q., Mandar trabajos

Comando send_orca

El comando send_orca envía los cálculos orca de un modo sencillo al sistema de colas.

Recomendamos el uso del comando send_orca. Este comando preparará script de TORQUE y lo enviará a la cola. El fichero de out (*.out) se mantendrá en el /scratch del nodo de remoto, pero send_orca envía el trabajo de tal menera que puede ser visualizado con las herramientas remote_vi y remote_molden (ver más abajo).

modo de uso del comando send_orca es el siguiente:

send_orca trabajo cola_o_tiempo nim_nodes num_proc [mem] [opciones de TORQUE]

donde:

  • trabajo: Es el nombre del input de orca sin la extensión (*.inp).
  • cola o tiempo: Se puede indicar la cola a la que se quiere mandar el cálculo o el tiempo en formato (hh:mm:ss).
  • num_nodes: El número de nodos que se quiere usar-
  • num_proc: El número de procesadores que se quiere usar por nodo. Es posible añadir propiedades de los nodos, por ejemplo 8:xeon
  • mem:  la memoria en GB.
  • [opciones de TORQUE]: Opciones avanzadas que se quieren pasar al gestor de colas TORQUE.

Ejemplos

send_orca h2o p_slow 1 8

Enviará el trabajo h2o en  1 nodo y 8 procesadores a la cola p_slow con los valores de memoria predeterminados en este caso 7.2Gb (nproc*900mb).

send_orca h2o p_slow 2 8 20

Enviará el trabajo h2o en dos nodos y 8 procesadores en cada uno  a la cola p_slow con 20gb de memoria RAM.

send_orca h2o 23:00:00 16:xeon 4 ``-m be -M niri@ehu.es -W depend=afterany:4827''

Enviará el trabajo h2o en 2 nodos Xeony 8 procesadoeres en cada uno,  con 4gb de RAM. El tiempo solicitado son 23 horas, y nos enviará un email al inicio y final del cálculo. Por otra parte este trabajo no empezará hasta que termine el trabajo 4827.

Seguimiento del trabajo

Existen las herramietas remote_vi y remote_molden, que permiten ver el fichero .log o mostrar la estructura con Molden. Para ello hay que usarsend_gaussian o qsub interactivo. Su uso el el siguiente:

remote_vi 2341
remote_molden 2341

o

remote_vi 2341.arina
remote_molden 2341.arina

donde 2341(.arina) es el identificador del trabajo en la cola.

Cómo mandar Espresso

F.A.Q., Mandar trabajos

send_espresso

Para lanzar al sistema de colas trabajos de Quantum Espresso existe la utilidad send_espresso. Al ejecutarlo, muestra la sintaxis del comando, que se resume a continuación:

send_espresso input Executable Nodes Procs_per_node Time Mem [``Otherqueue options'' ]
Input Nombre del input de espresso sin extensión
Executable Nombre del programa de espresso que se quiere usar: pw.x, ph.x, cp.x,…
Nodos Número de nodos a los que se quiere mandar el cálculo
Procs_per_node: Número de procesadores por nodo
Time: Tiempo solicitado a la cola, formato hh:mm:ss
Mem Memoria en GB y sin especificar la unidad
[«Otras opciones de Torque»] Existe la posibilidad de pasar más variables al sistema de colas. Ver ejemplos más abajo

Ejemplos

Mandamos Espresso (binario pw.x) con el input job1.in a 1 nodo, 4 procesadores de ese nodo, con un tiempo solicitado de 4 horas y 1 GB de RAM:

send_espresso job1 pw.x 2 4 04:00:00 1

Mandamos espresso (car-parrinello) con el input job2.in a 2 nodos, 8 procesadores en cada nodo, con un tiempo solicitado de 192 horas, 8 GB de RAM y que se ejecute después del trabajo 1234.arina:

send_espresso job2 cp.x 2 8 192:00:00 8 ``-W depend=afterany:1234''

Mandamos espresso (binario ph.x) con el input job3.in a 8 nodos y 8 procesadores en cada nodo, con un tiempo solicitado de 200:00:00 horas, 64 GB de RAM (global) y que nos envíe un mensaje de correo al inicio y final del cálculo a la dirección especificada.

send_espresso job3 ph.x 8 8 200:00:00 64 ``-m be -M mi.email@ehu.es''

El comando send_espresso copia el contenido del directorio desde el que se lanza al /scratch o /gscratch -si se usan 2 o más nodos. Es allí donde realiza el cálculo.

Cómo usar creando tu propio script para Torque

Los ejecutables de Espresso se encuentran instalados en /software/bin/espresso. Por ejemplo, para ejecutar pw.x en las colas usar:

source /software/Espresso/compilervars.sh
/software/Espresso/bin/pw.x -npool ncores < input_file > output_file

En la opción -npool ncores hay que sustituir ncores por el número de cores que se va a usar, esto mejora la velocidad de ejecución del cálculo. Si se solicitan más de un core se ejecuta automáticamente en paralelo.