Espere a que se complete el conjunto de trabajos de qsub

Question

Tengo un script de proceso por lotes que comienza con un par de trabajos de qsub, y quiero interceptarlos cuando se hayan completado.

No quiero usar la opción -sync, porque quiero que se ejecuten simultáneamente. Cada trabajo tiene un conjunto diferente de parámetros de línea de comando.

Quiero que mi secuencia de comandos espere hasta que se hayan completado todos los trabajos, y haga algo después de eso. No quiero usar la función dormir, p. para verificar si ciertos archivos se han generado después de cada 30 s, porque esto es un drenaje de recursos.

Creo que Torque puede tener algunas opciones, pero estoy ejecutando SGE.

Alguna idea sobre cómo podría implementar esto por favor?

Gracias P.s. Lo que encontrar otro hilo Link

que tenía un Reponse

Se puede utilizar para detener la ejecución esperar hasta que todos los trabajos se realizan. Incluso puede recopilar todos los estados de salida y otras estadísticas en ejecución (tiempo que tardó, recuento de trabajos realizados en el momento, lo que sea) si hace un ciclo esperando identificaciones específicas.

pero no estoy seguro de cómo usarlo sin sondear en algún valor. Se puede usar bash trap, pero ¿cómo lo haría con qsub?

Answer 1

qsub -hold_jid job1,job2,job3 -cwd ./myscript 

Answer 2

poner en marcha sus trabajos qsub, usando la opción -N para darles nombres arbitrarios (job1, job2, etc):

qsub -N job1 -cwd ./job1_script 
qsub -N job2 -cwd ./job2_script 
qsub -N job3 -cwd ./job3_script 

lance el guión y decirle que esperar hasta que los puestos de trabajo nombrados job1 , job2 y job3 están terminados antes de que comience:

qsub -hold_jid job1,job2,job3 -cwd ./results_script 

Answer 3

Otra alternativa (de here) es el siguiente:

FIRST=$(qsub job1.pbs) 
echo $FIRST 
SECOND=$(qsub -W depend=afterany:$FIRST job2.pbs) 
echo $SECOND 
THIRD=$(qsub -W depend=afterany:$SECOND job3.pbs) 
echo $THIRD 

La idea es que qsub devuelve el jobid y esto normalmente se descarga a la salida estándar. En su lugar, captúrelo en una variable ($FIRST, $SECOND, $THIRD) y utilice el indicador -W depend=afterany:[JOBIDs] cuando ponga sus trabajos en cola para controlar la estructura de dependencia de cuando se eliminen de la cola.

Answer 4

En caso de tener 150 archivos que desea procesar y poder ejecutar solo 15 cada vez, mientras que el otro está en espera en la cola puede establecer algo como esto.

# split my list files in a junk of small list having 10 file each 
awk 'NR%10==1 {x="F"++i;}{ print > "list_part"x".txt" }' list.txt 

qsub todos los puestos de trabajo, de tal manera que el primero de cada list_part * .txt sostienen el segundo .... el segundo posee la tercera ..... y así sucesivamente.

for list in $(ls list_part*.txt) ; do 
    PREV_JOB=$(qsub start.sh) # create a dummy script start.sh just for starting 
for file in $(cat $list) ; do 
    NEXT_JOB=$(qsub -v file=$file -W depend=afterany:$PREV_JOB myscript.sh) 
    PREV_JOB=$NEXT_JOB 
done 
done 

Esto es útil si usted tiene en myscript.sh un procedimiento que requiere movimiento o descargar muchos archivos o crear un tráfico intenso en el cluster-lan

Answer 5

Esto funciona en bash, pero las ideas debe ser portátil .Use -terse para facilitar la creación de una cadena con identificadores de trabajo para esperar; a continuación, enviar una tarea ficticia que utiliza -hold_jid que esperar en los trabajos anteriores y de manera que -sync y qsub no vuelve hasta que (y por lo tanto todos los prerrequisitos) ha terminado:

# example where each of three jobs just sleeps for some time: 
job_ids=$(qsub -terse -b y sleep 10) 
job_ids=job_ids,$(qsub -terse -b y sleep 20) 
job_ids=job_ids,$(qsub -terse -b y sleep 30) 
qsub -hold_jid ${job_ids} -sync y -b y echo "DONE" 

• -terse opción hace que la salida del qsub acaba de ser el ID de trabajo
• -hold_jid opción (como se ha mencionado en otras respuestas) hace una espera de trabajo en ID de trabajos especificados
• -sync y opción (referenciado por el PO) pregunta qsub no regresar hasta que se termine el trabajo presentado
• -b y especifica que el comando no es una ruta a un archivo de script (por ejemplo, estoy usando sleep 30 que el comando)

Véase el man page para más detalles.

Answer 6

Necesitaba más flexibilidad, así que construí un módulo de Python para este y otros fines here. Puede ejecutar el módulo directamente como un script (python qsub.py) para una demostración.

Uso:

$ git clone https://github.com/stevekm/util.git 
$ cd util 
$ python 
Python 2.7.3 (default, Mar 29 2013, 16:50:34) 
[GCC 4.4.7 20120313 (Red Hat 4.4.7-3)] on linux2 
Type "help", "copyright", "credits" or "license" for more information. 
>>> import qsub 
>>> job = qsub.submit(command = 'echo foo; sleep 60', print_verbose = True) 
qsub command is: 

qsub -j y -N "python" -o :"/home/util/" -e :"/home/util/" <<E0F 
set -x 
echo foo; sleep 60 
set +x 
E0F 

>>> qsub.monitor_jobs(jobs = [job], print_verbose = True) 
Monitoring jobs for completion. Number of jobs in queue: 1 
Number of jobs in queue: 0 
No jobs remaining in the job queue 
([Job(id = 4112505, name = python, log_dir = None)], []) 

Diseñado con Python 2.7 y SGE ya que eso es lo que ejecuta nuestro sistema. Las únicas bibliotecas de Python no estándares requeridos son los incluidos tools.py y log.py módulos y sh.py (también incluido)

Obviamente no es tan útil si desea permanecer únicamente en bash, pero si tiene que esperar en qsub empleos entonces imaginaría que su flujo de trabajo se está acercando a una complejidad que se beneficiaría del uso de Python en su lugar.

Answer 7

Si todos los trabajos tienen un patrón común en el nombre, puede proporcionar ese patrón cuando envíe los trabajos. https://linux.die.net/man/1/sge_types le muestra qué patrones puede usar. ejemplo:

-hold_jid "job_name_pattern*"