https://wiki.nlhpc.cl/api.php?action=feedcontributions&feedformat=atom&user=EguerraNLHPC - Contribuciones del usuario [es]2026-04-16T22:30:27ZContribuciones del usuarioMediaWiki 1.39.3https://wiki.nlhpc.cl/index.php?title=SISTEMA_GESTOR_DE_RECURSOS&diff=987SISTEMA GESTOR DE RECURSOS2025-06-26T21:54:59Z<p>Eguerra: </p>
<hr />
<div>== SLURM Workload Manager ==<br />
Es un sistema de programación de trabajos y gestión de clústeres de código abierto, tolerante a fallas y altamente escalable para clústeres Linux grandes y pequeños.<br />
<br />
Como administrador de carga de trabajo de clúster, Slurm tiene tres funciones clave. Primero, asigna acceso exclusivo y / o no exclusivo a los recursos (nodos de cómputo) a los usuarios durante un período de tiempo para que puedan realizar el trabajo. En segundo lugar, proporciona un marco para iniciar, ejecutar y monitorear el trabajo (normalmente un trabajo paralelo) en el conjunto de nodos asignados. Finalmente, arbitra la contención de recursos mediante la gestión de una cola de trabajo pendiente.<br />
<br />
SLURM es el gestor de colas instalado en muchos de los súper computadores del [https://www.top500.org/ TOP500], y también en el clúster del NLHPC. Si Ud. quiere lanzar tareas dentro de Leftaru, debe hacerlo a través de Slurm.<br />
<br />
== Conceptos clave ==<br />
SLURM gestiona trabajos de usuario que tienen las siguientes características clave:<br />
<br />
* Conjunto de recursos solicitados:<br />
** Número de recursos informáticos: nodos (incluidas todas sus CPUs y núcleos) o CPUs (incluidos todos sus núcleos) o solo núcleos<br />
** Cantidad de memoria: por nodo o por CPU (lógica)<br />
** Tiempo necesario para que las tareas del usuario completen su trabajo<br />
* Una partición de nodo solicitada (cola de trabajos)<br />
* Un nivel de calidad de servicio (QoS) solicitado que otorga a los usuarios accesos específicos<br />
* Una cuenta solicitada con recursos limitados<br />
<br />
De manera predeterminada, los usuarios envían trabajos a una partición particular (marcada como tal para todos los usuarios) y bajo una cuenta particular (preestablecida por usuario).<br />
<br />
== Particiones SLURM ==<br />
<br />
<table class="wikitable" style="width: 60%;"><br />
<tr><br />
<td><b>Nombre Particion</b></td><br />
<td><b>Nodos</b></td><br />
<td><b>CPUs</b></td><br />
<td><b>RAM</b></td><br />
<td><b>Descripción</b><br />
</td></tr><br />
<tr><br />
<td>main</td><br />
<td>27</td><br />
<td>256</td><br />
<td>768GB</td><br />
<td><br />
</td></tr><br />
<tr><br />
<td>general</td><br />
<td>48</td><br />
<td>44</td><br />
<td>187GB</td><br />
<td><br />
</td></tr><br />
<tr><br />
<td>largemem</td><br />
<td>9</td><br />
<td>44</td><br />
<td>765GB</td><br />
<td><br />
</td></tr><br />
<tr><br />
<td>v100</td><br />
<td>2</td><br />
<td>44</td><br />
<td>187GB</td><br />
<td>4 GPUs Nvidia Tesla V100.<br />
</td></tr><br />
<tr><br />
<td>mi100</td><br />
<td>1</td><br />
<td>128</td><br />
<td>502GB</td><br />
<td>2 GPUs AMD Instinct MI100.<br />
</td></tr><br />
<tr><br />
<td>mi210</td><br />
<td>2</td><br />
<td>24</td><br />
<td>1457GB</td><br />
<td>6 GPUs AMD Instinct MI210.<br />
</td></tr><br />
<tr><br />
<td>debug</td><br />
<td>2</td><br />
<td>48</td><br />
<td>768GB</td><br />
<td>Destinados a pruebas de máximo 30 minutos.<br />
</td></tr></table><br />
<br />
== Introducción a los comandos slurm ==<br />
<table class="wikitable" style="width: 60%;"><br />
<td><b>Comando SLURM</b></td><br />
<td><b>Descripción</b><br />
</td></tr><br />
<tr><br />
<td>srun</td><br />
<td>ejecutar un comando en nodos de cómputo asignados.<br />
</td></tr><br />
<tr><br />
<td>sbatch</td><br />
<td>presentar un script de trabajo<br />
</td></tr><br />
<tr><br />
<td>squeue</td><br />
<td>Mostrar estado de los trabajos en la cola.<br />
</td></tr><br />
<tr><br />
<td>scancel</td><br />
<td>eliminar un trabajo.<br />
</td></tr><br />
<tr><br />
<td>sinfo</td><br />
<td>Muestra el estado de los nodos de cómputo.<br />
</td></tr></table><br />
Estos son los comandos básicos utilizados para realizar la mayoría de las operaciones básicas con SLURM.<br />
<br />
=== Estado de nodos ===<br />
Para consultar el uso de nuestra infraestructura y qué particiones están más libres, le recomendamos el comando sinfo:<br />
<br />
<pre># sinfo<small><br />
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST<br />
main* up infinite 1 idle mn[016,018]<br />
main* up infinite 21 mix mn[001-003,005,007-011,013,015,017,019-027]<br />
main* up infinite 4 alloc mn[004,006,012,014]<br />
general up infinite 1 drain sn041<br />
general up infinite 16 mix sn[005-007,012-015,019-021,030-031,043-048]<br />
general up infinite 31 alloc sn[001-004,008-011,016-018,022-029,032-040]<br />
largemem up infinite 1 mix fn006<br />
largemem up infinite 8 alloc fn[001-005,007-009]<br />
debug up infinite 2 idle leftraru[1-2]<br />
v100 up infinite 2 mix gn[001-002]<br />
mi100 up infinite 1 idle gn003<br />
mi210 up infinite 1 mix gn004<br />
mi210 up infinite 1 idle gn005</small><br />
</pre><br />
<br />
Fijándose en el texto resaltado de la salida del comando sinfo, se puede comprobar que en la partición main hay 20 nodos que están completamente ocupados (estado alloc), 7 nodos que están libres (idle); por otro lado, en la partición general hay 22 nodos completamente ocupados, 4 parcialmente ocupados y 22 libres. Dado este escenario, está claro que debería de lanzar sus ejecuciones en los nodos de la partición general, por las razones anteriormente expuestas.<br />
<br />
Para lanzar en la partición general, debe tener en cuenta que tiene que indicar en su script que se use dicha partición en vez de, probablemente, main. Por supuesto, en esta partición cambian las características técnicas, se pasan a tener 44 cores por nodo (en vez de 256 en main) y una capacidad RAM de 187GB (en vez de 768GB en main). Puede ver más información de las particiones en este link(agregar link), donde podrá revisar que con la inclusión de Guacolda hemos añadido nodos con hasta 765GB de memoria RAM y nodos con GPUs Nvidia Tesla V100 y AMD Instinct MI100 .<br />
<br />
Para ver los nodos disponibles y poder determinar en que partición lanzar los trabajos se recomienda utilizar el siguiente comando.<br />
<br />
<pre>[prueba@leftraru1 ~]$ sinfo -o "%10P %6D %10t %10m %c" -t idle| egrep "PARTITION|main|general|largemem|v100|mi100|mi210"<br />
PARTITION NODES STATE MEMORY CPUS<br />
PARTITION NODES STATE MEMORY CPUS<br />
main* 2 idle 727000 256<br />
general 0 n/a 0 0<br />
largemem 0 n/a 0 0<br />
v100 0 n/a 0 0<br />
mi100 1 idle 485000 128<br />
mi210 1 idle 1457000 48<br />
</pre><br />
<br />
El comando anterior muestra que main tiene 27 nodos libres, en este caso es recomendado lanzar en en main para evitar que el trabajo quede en cola por falta de recursos en otros nodos.<br />
<br />
Otro Ejemplo, se muestra sólo una partición específica<br />
<br />
<pre>[prueba@leftraru1 ~]$ sinfo -p main<br />
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST<br />
main* up infinite 15 mix mn[001-008,014-020]<br />
main* up infinite 12 idle mn[009-013,021-027]<br />
</pre><br />
<br />
=== Comprobación del estado de tareas ===<br />
squeue - Muestra el estatus de los trabajos<br />
<br />
<pre>squeue # tus trabajos<br />
squeue -u &lt;username&gt; # trabajos por usuario &lt;username&gt;<br />
</pre><br />
<br />
squeue: Comprobar estados de los trabajos<br />
<br />
<div style="" class="mw-highlight mw-content-ltr" dir="ltr"><br />
<pre><br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
13951858_1 general test1 test1 R 1-18:35:14 2 cn[009-010]<br />
13951857_2 general test2 test1 R 1-18:36:11 2 cn[099-100]<br />
13956453 gpu test3 test3 R 1-03:42:08 1 cn039<br />
13956449 largemem test4 test4 R 1-05:42:08 1 cn044<br />
</pre><br />
<br />
Puede utilizar squeue para saber el estado de una o varias de sus tareas<br />
<br />
<pre><br />
$ squeue -o "%.15i %.6P %.8j %.20S %.11M %.11L %.20V %.10Q %.4C %.2D %.6m" -S -t,-Q<br />
JOBID PARTIT NAME START_TIME TIME TIME_LEFT SUBMIT_TIME PRIORITY CPUS NO MIN_ME<br />
10837561 general TEST1 2018-06-18T18:51:01 19:00:31 2-04:59:29 2018-06-18T18:51:01 119972 1 1 1000M<br />
10838562 general TEST2 2018-06-19T11:30:47 2:20:45 2-21:39:15 2018-06-19T11:30:46 119946 1 1 1000M<br />
</pre><br />
<br />
<br />
para mas opciones puede revisar con el comando [https://slurm.schedmd.com/squeue.html man squeue] las opciones restantes.<br />
<br />
=== Códigos de ESTADO de los trabajos ===<br />
<br />
Los trabajos suelen pasar por varios estados durante su ejecución. Los estados típicos son PENDIENTE, EN EJECUCIÓN, SUSPENDIDO, FINALIZANDO y TERMINADO. A continuación se explica cada estado.<br />
<br />
'''BF''' BOOT_FAIL<br />
Trabajo finalizado debido a un fallo de arranque, normalmente debido a un fallo de hardware (por ejemplo, no se puede arrancar el nodo o bloque y el trabajo no se puede volver a poner en cola). <br />
<br />
'''CA''' CANCELADO<br />
El trabajo ha sido cancelado explícitamente por el usuario o el administrador del sistema. El trabajo puede haberse iniciado o no. <br />
<br />
'''CD''' TERMINADO<br />
El trabajo ha terminado todos los procesos en todos los nodos con un código de salida de cero. <br />
<br />
'''CF''' CONFIGURANDO<br />
Al trabajo se le han asignado recursos, pero están esperando a que estén listos para su uso (por ejemplo, arrancando). <br />
<br />
'''CG''' COMPLETANDO<br />
El trabajo está en proceso de finalización. Algunos procesos en algunos nodos pueden estar aún activos. <br />
<br />
'''DL''' FECHA LÍMITE<br />
El trabajo ha finalizado en la fecha límite. <br />
<br />
'''F''' FALLÓ<br />
Trabajo finalizado con un código de salida distinto de cero u otra condición de fallo. <br />
<br />
'''NF''' NODO_FAIL<br />
Trabajo finalizado debido al fallo de uno o más nodos asignados. <br />
<br />
'''OOM''' OUT_OF_MEMORY<br />
El trabajo ha experimentado un error de memoria insuficiente. <br />
<br />
'''PD''' PENDIENTE<br />
El trabajo está pendiente de asignación de recursos. <br />
<br />
'''PR''' PREEMPTED<br />
El trabajo ha finalizado debido a una espera. <br />
<br />
'''R''' EN MARCHA<br />
El trabajo tiene actualmente una asignación. <br />
<br />
'''RD''' RESV_DEL_HOLD<br />
El trabajo se está reteniendo después de que se eliminara la reserva solicitada. <br />
<br />
'''RF''' REQUEUE_FED<br />
El trabajo está siendo solicitado por una federación. <br />
<br />
'''RH''' REQUEUE_HOLD<br />
Se está volviendo a poner en cola un trabajo retenido. <br />
<br />
'''RQ''' REQUEUED<br />
Se está poniendo en cola un trabajo que se está completando. <br />
<br />
'''RS''' CAMBIO DE TAMAÑO<br />
El trabajo está a punto de cambiar de tamaño. <br />
<br />
'''RV''' REVOCADO<br />
El trabajo se ha retirado del clúster debido a que otro clúster ha iniciado el trabajo. <br />
<br />
'''SI''' SEÑALANDO<br />
El trabajo está siendo señalizado. <br />
<br />
'''SE''' SPECIAL_EXIT<br />
El trabajo se ha puesto en cola en un estado especial. Este estado puede ser establecido por los usuarios, normalmente en EpilogSlurmctld, si el trabajo ha terminado con un valor de salida particular. <br />
<br />
'''SO''' STAGE_OUT<br />
El trabajo está preparando los archivos. <br />
<br />
'''ST''' PARADO<br />
El trabajo tiene una asignación, pero la ejecución se ha detenido con la señal SIGSTOP. Los CPUS han sido retenidos por este trabajo. <br />
<br />
'''S''' SUSPENDIDO<br />
El trabajo tiene una asignación, pero se ha suspendido la ejecución y se han liberado CPUs para otros trabajos. <br />
<br />
'''TO''' TIMEOUT<br />
El trabajo ha finalizado al alcanzar su límite de tiempo.<br />
<br />
=== Cancelar un trabajo ===<br />
Con scancel se puede cancelar un trabajo en ejecución<br />
<pre>scancel &lt;jobID&gt; # Matar proceso &lt;jobID&gt;. (puede obtener el ID del job con "squeue")<br />
scancel -u &lt;username&gt; # Matar proceso por usuario &lt;username&gt;. <br />
</pre><br />
<pre>[prueba@leftraru1 ~]$ squeue -u prueba<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
45594 main TEST prueba R 0:59 3 mn[001-003]<br />
</pre><br />
<pre>[prueba@leftraru1 ~]$ scancel 45594<br />
[prueba@leftraru1 ~]$ squeue -u prueba<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
[prueba@leftraru1 ~]$<br />
</pre><br />
<br />
=== Ver estado de trabajos ===<br />
Para revisar el detalle de las opciones de un trabajo: scontrol show job<br />
<br />
<pre><br />
$ scontrol show job 10837561<br />
JobId=10837561 JobName=TEST1<br />
UserId=usuario(1000) GroupId=group(1000) MCS_label=N/A<br />
Priority=1100 Nice=0 Account=account QOS=120<br />
JobState=RUNNING Reason=None Dependency=(null)<br />
Requeue=0 Restarts=0 BatchFlag=1 Reboot=0 ExitCode=0:0<br />
DerivedExitCode=0:0<br />
RunTime=19:03:08 TimeLimit=3-00:00:00 TimeMin=N/A<br />
SubmitTime=2018-06-18T18:51:01 EligibleTime=2018-06-18T18:51:01<br />
StartTime=2018-06-18T18:51:01 EndTime=2018-06-21T18:51:01 Deadline=N/A<br />
PreemptTime=None SuspendTime=None SecsPreSuspend=0<br />
Partition=main AllocNode:Sid=leftraru2:5471<br />
ReqNodeList=(null) ExcNodeList=(null)<br />
NodeList=cn021<br />
BatchHost=cn021<br />
NumNodes=1 NumCPUs=1 NumTasks=1 CPUs/Task=1 ReqB:S:C:T=0:0:*:*<br />
TRES=cpu=1,mem=1000M,node=1<br />
Socks/Node=* NtasksPerN:B:S:C=1:0:*:* CoreSpec=*<br />
Nodes=cn021 CPU_IDs=1 Mem=1000 GRES_IDX=<br />
MinCPUsNode=1 MinMemoryCPU=1000M MinTmpDiskNode=0<br />
Features=(null) DelayBoot=00:00:00<br />
Gres=(null) Reservation=(null)<br />
OverSubscribe=OK Contiguous=0 Licenses=matlab Network=(null)<br />
Command=/home/usuario/script.sh<br />
WorkDir=/home/usuario/<br />
StdErr=/home/usuario/10837561_%x.err<br />
StdIn=/dev/null<br />
StdOut=/home/usuario/10837561_%x.out<br />
Power=<br />
BatchScript=<br />
</pre><br />
<br />
Para ver el script asociado a un trabajo: scontrol write batch_script <job_id> -<br />
<br />
<pre><br />
$ scontrol write batch_script 10837561 -<br />
#!/bin/bash<br />
#SBATCH -J nombre_del_trabajo<br />
#SBATCH -p main<br />
#SBATCH -n 1<br />
#SBATCH --ntasks-per-node=1<br />
#SBATCH --mail-user=usaurio@correo.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o nombre_del_trabajo%j_%x.out<br />
#SBATCH -e nombre_del_trabajo%j_%x.err<br />
#SBATCH --license=matlab <br />
<br />
ml MATLAB/2017a<br />
<br />
matlab -nodisplay -nosplash -nodesktop < programa.m<br />
</pre><br />
<br />
== Ejecutando trabajos ==<br />
Actualmente contamos con 2 metodos de enviar trabajos bajo SLURM: '''sbatch''' and '''srun'''. A veces puede ser ventajoso ejecutar un solo comando en el clúster como prueba o realizar rápidamente una operación con recursos adicionales. 'srun' permite a los usuarios hacer esto, y comparte las mismas variables que 'sbatch' . STDOUT y STDERR para un trabajo 'srun' serán redirigidos a la pantalla del usuario. Ctrl-C cancelará un trabajo srun. '''sbatch''' enviará un script de trabajo para que lo ejecute el clúster. Los scripts de trabajo bajo SLURM son simplemente scripts de shell (* .sh) con un conjunto de solicitudes de recursos en la parte superior del script.<br />
<br />
<br />
Uso básico de srun:<br />
<br />
<pre><br />
srun <algúnComando><br />
</pre><br />
<br />
<br />
Ejemplo de salida (ejecutando el comando "hostname" para saber en que nodo se está ejecutando):<br />
<pre> $ srun hostname<br />
cn003<br />
</pre><br />
<br />
<br />
Para enviar un script de trabajo a SLURM:<br />
<pre>sbatch nombreScript.sh</pre><br />
<br />
<br />
Example output:<br />
<pre>$ sbatch test-job.sh<br />
Submitted batch job 1169</pre><br />
<br />
=== Variables Slurm ===<br />
Las variables en esta sección son obligatorias, y SLURM las determina para determinar dónde y cuándo se ejecutarán sus trabajos. Si no asigna un valor para estos, el planificador asignará a sus trabajos el valor predeterminado. Si no solicita específicamente recursos para un trabajo, se le asignará un conjunto de recursos predeterminados. Para obtener una lista de todas las variables disponibles, consulte la documentación de SLURM en http://slurm.schedmd.com/sbatch.html. Las variables de este artículo estaban cubiertas porque eran las más relevantes para los casos de uso típicos.<br />
<br />
<table class="wikitable" style="width: 100%;"><br />
<tr><br />
<td><b>Comando SLURM</b></td><br />
<td><b>Descripción</b><br />
</td></tr><br />
<tr><br />
<td>--mem-per-cpu=&lt;megabytes&gt;</td><br />
<td>Memoria requerida para el trabajo por CPU (en MegaBytes). El valor predeterminado es 1024 MB.<br />
</td></tr><br />
<tr><br />
<td>-p &lt;partition&gt;, --partition=&lt;partition&gt;</td><br />
<td>Enviar un trabajo a una partición específica.<br />
</td></tr><br />
<tr><br />
<td>-n, --ntasks=&lt;cantidad de tareas&gt;</td><br />
<td>Número de tareas que serán asignadas para el trabajo.<br />
</td></tr><br />
<tr><br />
<td>-c &lt;cpus&gt;</td><br />
<td>Esta es la cantidad de CPU que necesita su trabajo. Tenga en cuenta que SLURM es relativamente generoso con las CPU, y el valor especificado aquí es el número "mínimo" de CPU que se asignará a su trabajo. Si hay CPU adicionales disponibles en un nodo más allá de lo solicitado, su trabajo recibirá esas CPU hasta que otros trabajos las necesiten. El valor predeterminado es 1 CPU. Intentar usar más CPU de las que se le asignaron dará como resultado que sus procesos adicionales se turnen en la misma CPU (ralentizando su trabajo).<br />
</td></tr><br />
<tr><br />
<td>-J &lt;name&gt;, --jobname=&lt;name&gt;</td><br />
<td>Especifica un nombre a tu trabajo.<br />
</td></tr><br />
<tr><br />
<td>--mail-type=BEGIN,END,FAIL,ALL<b> and </b>--mail-user=&lt;emailAddress&gt;</td><br />
<td>Enviar por correo electrónico cuando su trabajo comienza / termina / falla. Puede especificar varios valores para esto (separados por comas) si es necesario.<br />
</td></tr><br />
<tr><br />
<td>-o &lt;STDOUT_log&gt;, --output=&lt;STDOUT_log&gt;</td><br />
<td>Redirija la salida a los archivos de registro que especifique. Por defecto, ambos, STDOUT and STDERR son enviados a este archivo. Puedes especificar %j como parte del nombre de archivo de registro para indicar la ID del trabajo (como ejemplo, "#SBATCH -o ouptut_%j.o" redirigiría la salida a "output_123456.o").<br />
</td></tr><br />
<tr><br />
<td>-e &lt;STDERR_log&gt;, --error=&lt;STDERR_log&gt;</td><br />
<td>Redireccionar STDERR a un archivo separado. Funciona exactamente igual que "-o".<br />
</td></tr><br />
<tr><br />
<td>-t &lt;days-hours:minutes:seconds&gt;</td><br />
<td>Walltime para tu trabajo. La duración del Walltime es el tiempo que espera que su trabajo se ejecute.<br />
</td></tr><br />
<tr><br />
<td>-a, --array=&lt;índices&gt;</td><br />
<td>Envía una lista (arreglo) de trabajos identicos. Solo aplica para sbatch.<br />
</td></tr></table><br />
<br />
<br />
Los scripts de trabajo especifican los recursos solicitados y otras consideraciones especiales con comentarios especiales "#SBATCH" en la parte superior de un script de trabajo. Aunque muchas de estas opciones son opcionales, las varibles que se ocupan de solicitudes de recursos (CPU, memoria y tiempo) son obligatorias. Todas las variables deben agregarse a sus scripts de la siguiente manera:<br />
<br />
<pre>#SBATCH <variable></pre><br />
Para especificar un nombre al job, por ejemplo, debe agregar lo siguiente a su secuencia de comandos:<br />
<br />
<pre>#SBATCH --job-name=nombreDeTrabajo</pre><br />
<br />
===Enviar un script===<br />
<pre> <br />
#!/bin/bash<br />
#SBATCH -J example<br />
#SBATCH -p general<br />
#SBATCH -n 1<br />
#SBATCH --output=example_%j.out<br />
#SBATCH --error=example_%j.err<br />
#SBATCH --mail-user=user@example.com<br />
#SBATCH --mail-type=ALL<br />
</pre><br />
<br />
Como debe comenzar un script en Linux:<br />
<pre><br />
#!/bin/bash<br />
</pre><br />
<br />
<br />
Nombre del trabajo:<br />
<pre><br />
#SBATCH -J example<br />
</pre><br />
<br />
<br />
Nombre la partición donde desea ejecutar el Job:<br />
<pre><br />
#SBATCH -p general<br />
</pre><br />
<br />
<br />
Número de tareas:<br />
<pre><br />
#SBATCH -n 1<br />
</pre><br />
<br />
<br />
Log de salida:<br />
<pre><br />
#SBATCH -o example_%j.out<br />
</pre><br />
<br />
<br />
Log de error:<br />
<pre><br />
#SBATCH -e example_%j.err<br />
</pre><br />
<br />
<br />
Correo para notificaciones:<br />
<pre><br />
#SBATCH --mail-user=user@example.com<br />
</pre><br />
<br />
<br />
Enviar correo en todos casos (verificar opciones arriba):<br />
<pre><br />
#SBATCH --mail-type=ALL<br />
</pre><br />
<br />
=== Programar tarea (uso de scrontab) ===<br />
'''scrontab''' es una implementación del clásico planificador de tareas de linux '''crontab''' donde se guarda un listado de comandos a ejecutar en un tiempo determinado por el usuario.<br />
<br />
Para acceder a scrontab utilice el siguiente comando:<br />
<pre><br />
[prueba@leftraru1 ~]$ scrontab -e<br />
</pre><br />
<br />
Esto le permitirá editar su archivo scrontab, asignando recursos como también el momento en que desea ejecutar su tarea. La estructura base a utilizar es la siguiente:<br />
<pre><br />
#SCRON -J mi_tarea<br />
#SCRON -p main<br />
#SCRON -n 1<br />
#SCRON -c 1<br />
#SCRON --mem-per-cpu=2300<br />
#SCRON --mail-user=foo@bar.com<br />
#SCRON --mail-type=ALL<br />
#SCRON -o mi_tarea_%j.out<br />
#SCRON -e mi_tarea_%j.err<br />
# Example of job definition:<br />
# .---------------- minute (0 - 59)<br />
# | .------------- hour (0 - 23)<br />
# | | .---------- day of month (1 - 31)<br />
# | | | .------- month (1 - 12) OR jan,feb,mar,apr ...<br />
# | | | | .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat<br />
# | | | | |<br />
# * * * * * command to be executed<br />
</pre><br />
<br />
* '''minute''' - Corresponde al minuto en que se va a ejecutar el script, valor de 0 a 59.<br />
* '''hour''' - Hora de ejecución, formato 24 horas, valor de 0 a 23, donde 0 son las 12:00 AM.<br />
* '''day of month''' - Día del mes, la tarea se puede ejecutar cada x día, valor de 1 a 31.<br />
* '''month''' - La tarea se puede ejecutar cada x mes, valor de 1 a 12.<br />
* '''day of week''' - Día de la semana, valor de 0 a 6, donde 0 es Domingo.<br />
* '''command to be executed''' - Script a ejecutar por el usuario.<br />
<br />
Ejemplo envío de trabajo slurm:<br />
<br />
Para la asignación de recursos, utilizaremos la directriz '''#SCRON''', que utiliza los mismos parámetros usados por '''#SBATCH'''.<br />
<br />
Luego de asignar los recursos debemos especificar el tiempo, en este caso la tarea será ejecutada todos los días cada 20 minutos, luego debemos indicar el script enviado por el usuario y guardamos los cambios en el archivo.<br />
<br />
<pre><br />
*/20 * * * * /home/prueba/ejemplo/script.sh<br />
</pre><br />
<br />
Es importante destacar que el script a lanzar '''/home/prueba/ejemplo/script.sh''' debe tener permisos de ejecución.<br />
<br />
Para revisar el listado de tareas existentes en nuestro scrontab, ejecutamos el comando:<br />
<pre><br />
[prueba@leftraru1 ~]$ scrontab -l<br />
*/20 * * * * /home/prueba/ejemplo/script.sh<br />
</pre><br />
<br />
<br />
Para borrar el contenido de nuestro scrontab:<br />
<pre><br />
[prueba@leftraru1 ~]$ scrontab -r<br />
</pre><br />
<br />
'''Información a considerar:'''<br />
<br />
* Generar archivos de salida correctamente<br />
** Para que el archivo error y out de tu script se generen en el directorio solicitado, ejemplo, /home/prueba/ejemplo/ en tu script debe estar presente el comando cd “/home/prueba/ejemplo”, esto hará que scrontab se posicione dentro del directorio de salida.<br />
* Es distinto el tiempo de programar el envío de una tarea (scrontab) a que una tarea inicie en el clúster (running), ya que esto dependerá de los recursos libres que existan en ese momento en el clúster.<br />
* Para revisar las tareas programadas debe ejecutar en cualquier nodo login el comando '''scrontab -l''' o revisar con el comando '''squeue''':<br />
<br />
<pre><br />
[prueba@leftraru1 ~]$ squeue<br />
24293471 main /home/eg prueba PD 0:00 1 (BeginTime)<br />
</pre><br />
<br />
== Checkpointing ==<br />
Es la acción de guardar el estado de un proceso en ejecución en un archivo de imagen de punto de control. Este proceso se puede reiniciar más tarde desde el archivo del punto de control, continuando la ejecución desde donde se detuvo, en la misma computadora o en una diferente.<br />
<br />
=== ¿Por qué utilizarlo? ===<br />
* Permite ejecuciones de tarea largas que superen el tiempo de ejecución permitido en el cluster (30 días)<br />
* Estar preparados ante fallas del sistema que nos puedan hacer perder resultados de nuestras simulaciones<br />
<br />
=== Utilización ===<br />
Lo primero que debemos hacer en nuestro script es cargar el módulo de Mana:<br />
<pre><br />
ml mana/3.0.0<br />
</pre><br />
Este módulo provee 3 ejecutables que necesitaremos:<br />
<br />
* '''mana_coordinator:''' Coordina los checkpoints entre los distintos procesos<br />
* '''mana_launch:''' Inicia un proceso con checkpoint<br />
* '''mana_restart:''' Reinicia la ejecución desde una imagen del checkpoint<br />
<br />
Necesitaremos 2 scripts para trabajar con checkpoints: Inicio y reinicio<br />
<br />
=== Script de inicio (inicio.sh) ===<br />
<pre><br />
#!/bin/bash<br />
##---------------SLURM Parameters - NLHPC ----------------<br />
#SBATCH -J Testcheckpoint<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4363<br />
#SBATCH --mail-user=test@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o Testcheckpoint_%j.out<br />
#SBATCH -e Testcheckpoint_%j.err<br />
<br />
# ----------------Modules----------------------------<br />
ml mana/3.0.0<br />
# ----------------Command--------------------------<br />
#Checkpointing cada 1 hora<br />
mana_cooridinator -i3600<br />
#Ejecutamos nuestra tarea con checkpointing<br />
srun mana_launch ./ejecutable<br />
</pre><br />
<br />
=== Script de reinicio (reinicio.sh) ===<br />
<pre><br />
#!/bin/bash<br />
##---------------SLURM Parameters - NLHPC ----------------<br />
#SBATCH -J Testcheckpoint<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4363<br />
#SBATCH --mail-user=test@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o Testcheckpoint_%j.out<br />
#SBATCH -e Testcheckpoint_%j.err<br />
<br />
# ----------------Modules----------------------------<br />
ml mana/3.0.0<br />
# ----------------Command--------------------------<br />
#Checkpointing cada 1 hora<br />
mana_cooridinator -i3600<br />
#Reiniciar nuestra tarea desde los archivos de checkpoint<br />
srun mana_restart<br />
</pre> <br />
<br />
<br />
Para correr estos scripts se puede hacer utilizando la funcionalidad de dependencias de SLURM:<br />
<pre><br />
[test@leftraru2 test]$ sbatch inicio.sh<br />
Submitted batch job 23574685<br />
[test@leftraru2 test]$ sbatch --dependency=afterok:23574685 reinicio.sh<br />
</pre><br />
<br />
== Trabajos ==<br />
=== Trabajos paralelos ===<br />
Muchos de los trabajos que se ejecutan en un clúster de producción implicarán más de un procesador (CPU, núcleo). Dichos trabajos paralelos deben solicitar la cantidad de recursos necesarios a través de opciones adicionales. Los más comunes son:<br />
<br />
Para diferentes tipos de trabajos paralelos, se especificarán diferentes opciones. Los trabajos paralelos más comunes son trabajos de MPI (memoria distribuida), trabajos de subprocesos múltiples (memoria compartida) y los llamados híbridos que son una combinación de los dos. Analicemos por separado con un n ejemplo para cada uno.<br />
<br />
=== Ejecución de programas con MPI ===<br />
MPI (interfaz de paso de mensajes) es la API de comunicación estándar para trabajos paralelos de memoria distribuida capaz de implementarse en un clúster. Para programar dicho trabajo, es necesario especificar la cantidad de nodos del clúster que se utilizarán y la cantidad de procesos (tareas) que se ejecutarán en cada nodo.<br />
<br />
El siguiente es un ejemplo de ejecución de un programa compilado con Open MPI:<br />
<br />
#!/bin/bash<br />
#SBATCH -J example_mpi<br />
#SBATCH -p general<br />
#SBATCH -n 264<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --output=example_%j.out<br />
#SBATCH --error=example_%j.err<br />
#SBATCH --mail-user=user@example.com<br />
#SBATCH --mail-type=ALL<br />
<br />
srun ./mpi_test<br />
A continuacion se explica línea por líneael script.<br />
<br />
Como empieza un shell script en Linux:<br />
<pre><br />
#!/bin/bash<br />
</pre><br />
<br />
<br />
Nombre del Job:<br />
<pre><br />
#SBATCH -J example_mpi<br />
</pre><br />
<br />
<br />
Nombre la particion donde se desea ejecutar el trabajo:<br />
<pre><br />
#SBATCH -p general<br />
</pre><br />
<br />
<br />
Número de tareas. Debe de ser un número múltiplo del número de CPUs máximo que tenga un node de la partición donde se lanza:<br />
<pre><br />
#SBATCH -n 264<br />
</pre><br />
<br />
<br />
Con esto se fuerza a que se lancen 44 tareas MPI en cada uno de los nodos, ocupando de este modo nodos completos. En este caso 6 nodos completos:<br />
<pre><br />
#SBATCH --ntasks-per-node=44<br />
</pre><br />
<br />
<br />
Log de salida:<br />
<pre><br />
#SBATCH -o example_%j.out<br />
</pre><br />
<br />
<br />
Log de error:<br />
<pre><br />
#SBATCH -e example_%j.err<br />
</pre><br />
<br />
<br />
Correo para notificaciones:<br />
<pre><br />
#SBATCH --mail-user=user@example.com<br />
</pre><br />
<br />
<br />
Envía correo en todos los casos:<br />
<pre><br />
#SBATCH --mail-type=ALL<br />
</pre><br />
<br />
<br />
Programa para ejecutar:<br />
<pre><br />
srun ./mpi_test<br />
</pre><br />
<br />
'''Nota''': no se carga específicamente el módulo "mpi" ya que se carga siempre por defecto.<br />
<br />
Para enviarlo al clúster debe ejecutar el comando: ''sbatch script.sh''. El ejemplo anterior ejecutará una tarea OpenMPI con 264 procesos reservando 264 cores para ello.<br />
<br />
=== Trabajos multiproceso OpenMP ===<br />
Los trabajos paralelos diseñados para ejecutarse en un sistema multi-core (shared-memory) suelen ser "multi-threaded". La programación de un job de este tipo requiere especificar el número de núcleos que se utilizan para acomodar los subprocesos.<br />
<br />
OpenMP es el conjunto común de variables de compilación para facilitar el desarrollo de programas multi-threaded. Un script típico de SLURM para un programa de este tipo se ve así:<br />
<pre><br />
#!/bin/bash<br />
#SBATCH -J OMPtest<br />
#SBATCH -p general<br />
#SBATCH -n 1<br />
#SBATCH -c 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=1024<br />
#SBATCH -o example_%j.out<br />
#SBATCH -e example_%j.err<br />
#SBATCH --mail-user=user@example.com<br />
#SBATCH --mail-type=ALL<br />
<br />
OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK time ./omp-program<br />
</pre><br />
<br />
<br />
Como debe comenzar un script en Linux:<br />
<pre><br />
#!/bin/bash<br />
</pre><br />
<br />
<br />
Nombre del Job:<br />
<pre><br />
#SBATCH -J OMPtest<br />
</pre><br />
<br />
<br />
Nombre la particion donde desea ejecutar el Job:<br />
<pre><br />
#SBATCH -p general<br />
</pre><br />
<br />
<br />
Número de trabajos:<br />
<pre><br />
#SBATCH -n 1<br />
</pre><br />
<br />
<br />
Número de tareas:<br />
<pre><br />
#SBATCH -c 44<br />
</pre><br />
<br />
<br />
Con esto se fuerza a que se agrupen las 44 tareas en un nodo (en OpenMP no hay comunicación entre nodos, por lo que todas las tareas deben estar en el mismo nodo o no funcionaría):<br />
<pre><br />
#SBATCH --ntasks-per-node=44<br />
</pre><br />
<br />
<br />
Memoria por core (MBytes):<br />
<pre><br />
#SBATCH --mem-per-cpu=1024<br />
</pre><br />
<br />
<br />
Log de salida:<br />
<pre><br />
#SBATCH -o example_%j.out<br />
</pre><br />
<br />
<br />
Log de error:<br />
<pre><br />
#SBATCH -e example_%j.err<br />
</pre><br />
<br />
<br />
Correo para notificaciones:<br />
<pre><br />
#SBATCH --mail-user=user@example.com<br />
</pre><br />
<br />
<br />
Enviar correo en todos los casos:<br />
<pre><br />
#SBATCH --mail-type=ALL<br />
</pre><br />
<br />
<br />
Programa para ejecutar:<br />
<pre><br />
OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK time ./omp-program <br />
</pre><br />
<br />
<br />
Cuando se utiliza un programa OpenMP, el número de subprocesos (y, por lo tanto, el número requerido de núcleos) se especifica a través de la variable de entorno OMP_NUM_THREADS que, por lo tanto, aparece en el script frente a la llamada al programa. Lo estamos configurando en la variable interna SLURM_CPUS_PER_TASK que se establece a través de la opción "-c" (a 44 en nuestro ejemplo, que sería el número total de cores de un nodo de la partición "general").<br />
<br />
La opción "-n" se mantiene en 1 para indicar un único trabajo principal que tiene 44 tareas. Para asegurarnos que todas las tareas se ejecutan en el mismo nodo, se añade la opción "--ntasks-per-node" con el máximo número de cores que tiene un nodo de la partición donde se está lanzando el trabajo.<br />
<br />
=== Ejecución de tareas en GPUs ===<br />
<pre><br />
#!/bin/bash<br />
#SBATCH -J ejemplo_gpus<br />
#SBATCH -p v100<br />
#SBATCH -n 1<br />
#SBATCH -o ejemplo_%j.out<br />
#SBATCH -e ejemplo_%j.err<br />
#SBATCH --mail-user=correo@gmail.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH --mem-per-cpu=4300<br />
#SBATCH --gres=gpu:1<br />
<br />
./programa<br />
</pre><br />
<br />
<br />
Inicio de un bash script en Linux:<br />
<pre><br />
#!/bin/bash<br />
</pre><br />
<br />
<br />
Nombre del trabajo:<br />
<pre><br />
#SBATCH -J ejemplo_gpus<br />
</pre><br />
<br />
<br />
Nombre la partición donde se ejecuta el trabajo:<br />
<pre><br />
#SBATCH --partition=v100<br />
</pre><br />
<br />
<br />
Número de tareas:<br />
<pre><br />
#SBATCH -n 1<br />
</pre><br />
<br />
<br />
Log de salida:<br />
<pre><br />
#SBATCH -o ejemplo_%j.out<br />
</pre><br />
<br />
<br />
Log de error:<br />
<pre><br />
#SBATCH -e ejemplo_%j.err<br />
</pre><br />
<br />
<br />
Correo para notificaciones:<br />
<pre><br />
#SBATCH --mail-user=user@example.com<br />
</pre><br />
<br />
<br />
Enviar correo en todos los casos:<br />
<pre><br />
#SBATCH --mail-type=ALL<br />
</pre><br />
<br />
<br />
Memoria por CPU (MB):<br />
<pre><br />
#SBATCH --mem-per-cpu=4365<br />
</pre><br />
<br />
<br />
Cantidad utilizada de GPUs. El parámetro gpu:1 indica la cantidad de tarjetas a utilizar (cada nodo tiene 2 GPUs):<br />
<pre><br />
#SBATCH --gres=gpu:1<br />
</pre><br />
<br />
<br />
Programa para ejecutar:<br />
<pre><br />
./programa<br />
</pre><br />
<br />
=== Job Arrays ===<br />
Cuando se ejecutan cientos o miles de simulaciones que utilizan la misma cantidad de recursos, puede ser una ventaja ejecutar estas simulaciones como un "job array". Los job array le permiten enviar miles de dichos trabajos (llamados "job steps") con un solo script. A cada simulación se le asignará un valor único para la variable de entorno SLURM_ARRAY_TASK_ID. Puede usar esta variable para leer parámetros para pasos individuales de una línea dada de un archivo.<br />
<br />
=== Caso de uso de un Script Job Array (Gaussian) ===<br />
Tenemos usuarios que actualmente envían varias simulaciones al clúster que son similares en cuanto al uso de recursos, pero, la diferencia es que solo cambia la entrada que le entregan al programa. Para esta situación, recomendamos hacer uso de un script Job Array.<br />
<br />
En este ejemplo crearemos un script job array para el software Gaussian, el cual, realizará 63 simulaciones, cada una de estas utilizará 8 cores y podrá alcanzar un uso máximo de 8 Gb de memoria ram. Para este caso utilizaremos la partición general donde cada nodo tiene 46 Gb de memoria ram y 20 cores.<br />
<br />
Script:<br />
<pre><br />
#!/bin/bash<br />
# ----------------SLURM Parameters----------------<br />
#SBATCH -J prueba<br />
#SBATCH -p general<br />
#SBATCH -n 1<br />
#SBATCH -c 8<br />
#SBATCH --mem-per-cpu=1000<br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH --array=1-63<br />
#SBATCH -o prueba_%A_%a.out<br />
#SBATCH -e prueba_%A_%a.err<br />
#-----------------Toolchain---------------------------<br />
ml purge<br />
ml intel/2019b<br />
# ----------------Módulos-----------------------------<br />
ml g16/B.01<br />
# ----------------Comandos--------------------------<br />
file=$(ls Child_10_*.com | sed -n ${SLURM_ARRAY_TASK_ID}p)<br />
srun g16 $file<br />
</pre><br />
<br />
'''<br />
Descripción de comandos utilizados en script:'''<br />
<br />
Inicio de un bash script en Linux:<br />
<pre><br />
#!/bin/bash<br />
</pre><br />
<br />
<br />
Nombre de la simulación:<br />
<pre><br />
#SBATCH -J prueba<br />
</pre><br />
<br />
<br />
Nombre la partición donde se ejecuta la simulación:<br />
<pre><br />
#SBATCH -p general<br />
</pre><br />
<br />
<br />
Número de tareas (1 tarea va a ejecutar 63 simulaciones):<br />
<pre><br />
#SBATCH -n 1<br />
</pre><br />
<br />
<br />
Core’s por tareas (cada tarea utilizará un máximo 8 cores):<br />
<pre><br />
#SBATCH -c 8<br />
</pre><br />
<br />
<br />
Memoria ram por cpu (cada tarea utilizará un máximo 8 Gb de ram):<br />
<pre><br />
#SBATCH –mem-per-cpu=1000<br />
</pre><br />
<br />
<br />
Correo para activar el envío de notificaciones:<br />
<pre><br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
</pre><br />
<br />
<br />
Permitir envío de notificaciones:<br />
<pre><br />
#SBATCH --mail-type=ALL<br />
</pre><br />
<br />
<br />
Se generan 63 simulaciones diferentes:<br />
<pre><br />
#SBATCH --array=1-63<br />
</pre><br />
<br />
<br />
Log de salida: (ejemplo: prueba_18455017_1.out)<br />
<br />
* %A corresponde al Job ID de nuestra tarea que le asignará Slurm → 18455017.<br />
* %a corresponde a la simulación X de nuestra tarea que le asignará Slurm → 1.<br />
<pre><br />
#SBATCH -o prueba_%A_%a.out<br />
</pre><br />
<br />
<br />
Log de errores: (ejemplo: prueba_18455017_1.err)<br />
<br />
* %A corresponde al Job ID de nuestra tarea que le asignará Slurm → 18455017.<br />
* %a corresponde a la simulación X de nuestra tarea que le asignará Slurm → 1.<br />
<br />
<pre><br />
#SBATCH -e prueba_%A_%a.err<br />
Toolchain: en este apartado, limpiaremos nuestro entorno de software no deseados y luego escogemos la herramienta informática con la cual está compilado el software Gaussian (nosotros utilizamos el compilador Intel/2019b).<br />
<br />
#-----------------Toolchain---------------------------<br />
ml purge<br />
ml intel/2019b<br />
Módulos: cargamos el software Gaussian versión 16/B.0.<br />
<br />
# ----------------Módulos-----------------------------<br />
ml g16/B.01<br />
Comandos: aquí definimos los comandos a ejecutar.<br />
<br />
# ----------------Comandos--------------------------<br />
file=$(ls Child_10_*.com | sed -n ${SLURM_ARRAY_TASK_ID}p)<br />
srun g16 $file<br />
</pre><br />
file= variable que va a listar los archivos de entrada que comiencen por Child_10_ y terminen en .com<br />
<br />
[[Archivo:Child.png|no]]<br />
<br />
<br />
sed -n ${SLURM_ARRAY_TASK_ID}p) ← Sed imprimirá las líneas de cada archivo de entrada y la variable $SLURM_ARRAY_TASK_ID asumirá estas entradas como matriz de simulación en nuestro job array, en este ejemplo tenemos 63 archivos de entrada.<br />
<br />
Para más detalles sobre los archivos stdin, stdout y stderr de una simulación % A será reemplazado por el valor de SLURM_ARRAY_JOB_ID que es el Job ID de nuestra tarea y %a será reemplazado por el valor de SLURM_ARRAY_TASK_ID que corresponde a la simulación X de nuestra tarea.<br />
<br />
Srun g16 $file: ejecutará el comando gaussian g16 interpretando la variable $file en los nodos de cómputo asignados.<br />
<br />
Enviar el script:<br />
<pre><br />
[prueba@leftraru1 ~]$ sbatch prueba.sh<br />
</pre><br />
<br />
=== Ejecución de una tarea que ocupa mucha RAM por CPU ===<br />
Debemos tener en cuenta que la RAM que SLURM reserva por defecto son 1000 MB. Un típico error de cancelación de tarea por falta de memoria es el siguiente:<br />
<pre><br />
/tmp/slurmd/job136839939/slurm_script: line 15: 23547 Killed ./programa.sh<br />
slurmstepd: error: Detected 1 oom-kill event(s) in step 136839939.batch cgroup. Some of your processes <br />
may have been killed by the cgroup out-of-memory handler.<br />
</pre><br />
<br />
<br />
Si su tarea ocupa más de la memoria por defecto, puede utilizar el siguiente parámetro:<br />
<pre><br />
#SBATCH --mem-per-cpu=2300 #Máxima RAM por CPU<br />
</pre><br />
Esto hará que SLURM reserve más RAM por CPU para sus tareas.<br />
<br />
Tenga en cuenta que nuestros nodos tienen 46 GB de memoria RAM (Partición slims), 187 GB (Partición general) y 765 GB (Partición largemem) por nodo. [https://wiki.nlhpc.cl/Hardware_Disponible Más información].<br />
<br />
Otra forma de reservar memoria es utilizando el siguiente parámetro:<br />
<br />
<pre><br />
#SBATCH --mem=2300<br />
</pre><br />
En este caso SLURM realizará una reserva de memoria de 2300 MB pero por la totalidad del trabajo.<br />
<br />
Los parámetros anteriores al igual que el número de CPUs que se van a usar, hay que afinarlos lo mejor posible. Para ello lo que se puede hacer es hacer pruebas en los nodos logins, sin lanzar en las colas, y así estudiar el uso de RAM y CPU por parte de sus procesos.<br />
<br />
=== Ejecución de una tarea con Dependencias ===<br />
Las dependencias de trabajos se utilizan para aplazar el inicio de un trabajo hasta que se satisfagan las dependencias especificadas. Se especifican con la opción --dependency en el siguiente formato:<br />
<pre><br />
sbatch --dependency=<type:job_id[:job_id][,type:job_id[:job_id]]> ...<br />
</pre><br />
Los tipos de dependencias son las siguientes:<br />
<br />
* '''after''':jobid[:jobid...] - el trabajo puede empezar después de que los trabajos especificados comiencen<br />
* '''afterany''':jobid[:jobid...] - el trabajo puede empezar después de que los trabajos especificados terminen<br />
* '''afternotok''':jobid[:jobid...] - el trabajo puede empezar después que los trabajos especificados terminan fallidamente<br />
* '''afterok''':jobid[:jobid...] - el trabajo puede empezar después que los trabajos especificados terminan exitósamente<br />
<br />
La manera más simple de usar una dependencia del tipo afterok:<br />
<pre><br />
[prueba@leftraru1 ~]$ sbatch job1.sh<br />
Submitted batch job 21363626<br />
[prueba@leftraru1 ~]$ sbatch --dependency=afterok:21363626 job2.sh<br />
</pre><br />
<br />
Ahora cuando job1.sh termine correctamente, el job2.sh entrará en ejecución. Si job1.sh termina fallidamente, job2.sh no entrará en ejecución nunca pero sí quedará en cola (debe cancelarse manualmente el trabajo).<br />
<br />
==== Capturando el Job ID para facilitar la ejecución de varias tareas con dependencias ====<br />
Es posible capturar en una variable el Job ID de cada tarea para poder lanzar varias tareas sin conocer el Job ID previamente.<br />
<br />
Por ejemplo, si se desea lanzar 4 tareas que sean dependientes con la anterior, se comenzará lanzando la primera tarea y capturando en la variable '''$JOB1''', el que será utilizado como dependencia en la tarea '''$JOB2''', y así sucesivamente.<br />
<br />
<pre><br />
JOB1=$(sbatch job_1.sbatch 2>&1 | awk '{print $4}')<br />
JOB2=$(sbatch --dependency=afterok:$JOB1 job_2.sbatch 2>&1 | awk '{print $4}')<br />
JOB3=$(sbatch --dependency=afterok:$JOB2 job_3.sbatch 2>&1 | awk '{print $4}')<br />
JOB4=$(sbatch --dependency=afterok:$JOB3 job_4.sbatch 2>&1 | awk '{print $4}')<br />
</pre><br />
<br />
== Prioridad de tarea ==<br />
Cómo ver la prioridad del trabajo. Los factores que determinan la prioridad del trabajo, incluyendo la fórmula y pesos.<br />
<br />
=== Factores que determinan prioridad de tarea ===<br />
<table class="wikitable" style="width: 60%;"><br />
<tr><br />
<td><b>Comando SLURM</b></td><br />
<td><b>Descripción</b><br />
</td></tr><br />
<tr><br />
<td>Edad</td><br />
<td>la cantidad de tiempo que el trabajo ha estado esperando en la cola.<br />
</td></tr><br />
<tr><br />
<td>Tamaño de la tarea</td><br />
<td>número de nodos solicitados por el trabajo.<br />
</td></tr><br />
<tr><br />
<td>Partición</td><br />
<td>prioridad para una partición determinada.<br />
</td></tr><br />
<tr><br />
<td>Prioridad Baja</td><br />
<td>Mientras más tareas se ejecuten en el cluster, menor será la prioridad.<br />
</td></tr><br />
<tr><br />
<td>Prioridad Alta</td><br />
<td>Mientras menos tareas se ejecuten en el clúster, más alta es la prioridad.<br />
</td></tr></table><br />
<br />
== Prioridad de tarea ==<br />
Cómo ver la prioridad del trabajo. Los factores que determinan la prioridad del trabajo, incluyendo la fórmula y pesos.<br />
<br />
=== Factores que determinan prioridad de tarea ===<br />
* Edad - la cantidad de tiempo que el trabajo ha estado esperando en la cola<br />
* Tamaño Oficio - número de nodos solicitados por el trabajo<br />
* Partición - prioridad para una partición determinada<br />
* Contribución de prioridades basada en los recursos informáticos utilizados por los miembros de un grupo de investigación en los últimos 30 días - Fairshare.<br />
* Mientras más tareas se ejecuten en el cluster, menor será la prioridad.<br />
* Mientras menos tareas se ejecuten en el clúster, más alta es la prioridad.<br />
Fórmula Prioridad de tarea<br />
<pre><br />
Job_priority =<br />
(PriorityWeightAge) * (age_factor) +<br />
(PriorityWeightFairshare) * (fair-share_factor) +<br />
(PriorityWeightJobSize) * (job_size_factor) +<br />
(PriorityWeightPartition) * (partition_factor) +<br />
(PriorityWeightQOS) * (QOS_factor)<br />
</pre><br />
<br />
== Visualización de sus Tareas ==<br />
Si Ud. necesita visualizar información acerca de sus tareas de forma interactiva, puede utilizar el comando smap:<br />
<br />
smap -i 3<br />
<br />
[[Archivo:Smap.png|no|700px]]<br />
<br />
<br />
De esta forma, tendrá una actualización cada 3 segundos de sus tareas en ejecución incluyendo los nodos en los cuales se encuentran ejecutándose.<br />
<br />
= Uso del parámetro <code>--time</code> (<code>-t</code>) en SLURM =<br />
<br />
El parámetro <code>--time</code> (o <code>-t</code>) en SLURM permite especificar el '''tiempo máximo de ejecución''' para un trabajo. Su uso correcto mejora la eficiencia del scheduler y permite aplicar estrategias como ''backfilling''.<br />
<br />
== Formato general ==<br />
<br />
<pre><br />
--time=D-HH:MM:SS<br />
</pre><br />
<br />
* '''D''': días (opcional)<br />
* '''HH''': horas (0–23)<br />
* '''MM''': minutos (0–59)<br />
* '''SS''': segundos (0–59)<br />
<br />
También puede usarse en formato corto con <code>-t</code>.<br />
<br />
== Ejemplos ==<br />
<br />
=== Trabajo de 1 hora ===<br />
<pre><br />
#SBATCH --time=01:00:00<br />
</pre><br />
<br />
o<br />
<br />
<pre><br />
#SBATCH -t 01:00:00<br />
</pre><br />
<br />
=== Trabajo de 4 horas y 30 minutos ===<br />
<pre><br />
#SBATCH --time=04:30:00<br />
</pre><br />
<br />
=== Trabajo de 2 días ===<br />
<pre><br />
#SBATCH --time=2-00:00:00<br />
</pre><br />
<br />
=== Trabajo de 15 minutos ===<br />
<pre><br />
#SBATCH --time=00:15:00<br />
</pre><br />
<br />
=== Trabajo de 3 días, 5 horas y 45 segundos ===<br />
<pre><br />
#SBATCH --time=3-05:00:45<br />
</pre><br />
<br />
== Ejemplo en script <code>job.sh</code> ==<br />
<br />
<pre><br />
#!/bin/bash<br />
#SBATCH --job-name=mi_trabajo<br />
#SBATCH --partition=general<br />
#SBATCH --ntasks=8<br />
#SBATCH --time=01:30:00 # 1 hora y 30 minutos<br />
#SBATCH --mem=16G<br />
<br />
srun ./mi_simulacion<br />
</pre><br />
<br />
== Recomendaciones ==<br />
<br />
* Estima lo mejor posible el tiempo necesario.<br />
* No omitas <code>--time</code>: si lo haces, SLURM asumirá un valor por defecto (como 5 días).<br />
* Para pruebas cortas, usa tiempos pequeños (por ejemplo, 10 minutos) para permitir el uso eficiente del scheduler mediante ''backfilling''.<br />
<br />
== Más información ==<br />
<br />
[https://slurm.schedmd.com/sbatch.html#OPT_time Documentación oficial de SLURM sobre el parámetro --time]<br />
<br />
== Bibliografía ==<br />
[http://slurm.schedmd.com/documentation.html Manual Oficial de Slurm]<br />
<br />
[https://slurm.schedmd.com/scrontab.html Documentación scrontab]</div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=SISTEMA_GESTOR_DE_RECURSOS&diff=986SISTEMA GESTOR DE RECURSOS2025-06-26T21:54:35Z<p>Eguerra: </p>
<hr />
<div>== SLURM Workload Manager ==<br />
Es un sistema de programación de trabajos y gestión de clústeres de código abierto, tolerante a fallas y altamente escalable para clústeres Linux grandes y pequeños.<br />
<br />
Como administrador de carga de trabajo de clúster, Slurm tiene tres funciones clave. Primero, asigna acceso exclusivo y / o no exclusivo a los recursos (nodos de cómputo) a los usuarios durante un período de tiempo para que puedan realizar el trabajo. En segundo lugar, proporciona un marco para iniciar, ejecutar y monitorear el trabajo (normalmente un trabajo paralelo) en el conjunto de nodos asignados. Finalmente, arbitra la contención de recursos mediante la gestión de una cola de trabajo pendiente.<br />
<br />
SLURM es el gestor de colas instalado en muchos de los súper computadores del [https://www.top500.org/ TOP500], y también en el clúster del NLHPC. Si Ud. quiere lanzar tareas dentro de Leftaru, debe hacerlo a través de Slurm.<br />
<br />
== Conceptos clave ==<br />
SLURM gestiona trabajos de usuario que tienen las siguientes características clave:<br />
<br />
* Conjunto de recursos solicitados:<br />
** Número de recursos informáticos: nodos (incluidas todas sus CPUs y núcleos) o CPUs (incluidos todos sus núcleos) o solo núcleos<br />
** Cantidad de memoria: por nodo o por CPU (lógica)<br />
** Tiempo necesario para que las tareas del usuario completen su trabajo<br />
* Una partición de nodo solicitada (cola de trabajos)<br />
* Un nivel de calidad de servicio (QoS) solicitado que otorga a los usuarios accesos específicos<br />
* Una cuenta solicitada con recursos limitados<br />
<br />
De manera predeterminada, los usuarios envían trabajos a una partición particular (marcada como tal para todos los usuarios) y bajo una cuenta particular (preestablecida por usuario).<br />
<br />
== Particiones SLURM ==<br />
<br />
<table class="wikitable" style="width: 60%;"><br />
<tr><br />
<td><b>Nombre Particion</b></td><br />
<td><b>Nodos</b></td><br />
<td><b>CPUs</b></td><br />
<td><b>RAM</b></td><br />
<td><b>Descripción</b><br />
</td></tr><br />
<tr><br />
<td>main</td><br />
<td>27</td><br />
<td>256</td><br />
<td>768GB</td><br />
<td><br />
</td></tr><br />
<tr><br />
<td>general</td><br />
<td>48</td><br />
<td>44</td><br />
<td>187GB</td><br />
<td><br />
</td></tr><br />
<tr><br />
<td>largemem</td><br />
<td>9</td><br />
<td>44</td><br />
<td>765GB</td><br />
<td><br />
</td></tr><br />
<tr><br />
<td>v100</td><br />
<td>2</td><br />
<td>44</td><br />
<td>187GB</td><br />
<td>4 GPUs Nvidia Tesla V100.<br />
</td></tr><br />
<tr><br />
<td>mi100</td><br />
<td>1</td><br />
<td>128</td><br />
<td>502GB</td><br />
<td>2 GPUs AMD Instinct MI100.<br />
</td></tr><br />
<tr><br />
<td>mi210</td><br />
<td>2</td><br />
<td>24</td><br />
<td>1457GB</td><br />
<td>6 GPUs AMD Instinct MI210.<br />
</td></tr><br />
<tr><br />
<td>debug</td><br />
<td>2</td><br />
<td>48</td><br />
<td>768GB</td><br />
<td>Destinados a pruebas de máximo 30 minutos.<br />
</td></tr></table><br />
<br />
== Introducción a los comandos slurm ==<br />
<table class="wikitable" style="width: 60%;"><br />
<td><b>Comando SLURM</b></td><br />
<td><b>Descripción</b><br />
</td></tr><br />
<tr><br />
<td>srun</td><br />
<td>ejecutar un comando en nodos de cómputo asignados.<br />
</td></tr><br />
<tr><br />
<td>sbatch</td><br />
<td>presentar un script de trabajo<br />
</td></tr><br />
<tr><br />
<td>squeue</td><br />
<td>Mostrar estado de los trabajos en la cola.<br />
</td></tr><br />
<tr><br />
<td>scancel</td><br />
<td>eliminar un trabajo.<br />
</td></tr><br />
<tr><br />
<td>sinfo</td><br />
<td>Muestra el estado de los nodos de cómputo.<br />
</td></tr></table><br />
Estos son los comandos básicos utilizados para realizar la mayoría de las operaciones básicas con SLURM.<br />
<br />
=== Estado de nodos ===<br />
Para consultar el uso de nuestra infraestructura y qué particiones están más libres, le recomendamos el comando sinfo:<br />
<br />
<pre># sinfo<small><br />
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST<br />
main* up infinite 1 idle mn[016,018]<br />
main* up infinite 21 mix mn[001-003,005,007-011,013,015,017,019-027]<br />
main* up infinite 4 alloc mn[004,006,012,014]<br />
general up infinite 1 drain sn041<br />
general up infinite 16 mix sn[005-007,012-015,019-021,030-031,043-048]<br />
general up infinite 31 alloc sn[001-004,008-011,016-018,022-029,032-040]<br />
largemem up infinite 1 mix fn006<br />
largemem up infinite 8 alloc fn[001-005,007-009]<br />
debug up infinite 2 idle leftraru[1-2]<br />
v100 up infinite 2 mix gn[001-002]<br />
mi100 up infinite 1 idle gn003<br />
mi210 up infinite 1 mix gn004<br />
mi210 up infinite 1 idle gn005</small><br />
</pre><br />
<br />
Fijándose en el texto resaltado de la salida del comando sinfo, se puede comprobar que en la partición main hay 20 nodos que están completamente ocupados (estado alloc), 7 nodos que están libres (idle); por otro lado, en la partición general hay 22 nodos completamente ocupados, 4 parcialmente ocupados y 22 libres. Dado este escenario, está claro que debería de lanzar sus ejecuciones en los nodos de la partición general, por las razones anteriormente expuestas.<br />
<br />
Para lanzar en la partición general, debe tener en cuenta que tiene que indicar en su script que se use dicha partición en vez de, probablemente, main. Por supuesto, en esta partición cambian las características técnicas, se pasan a tener 44 cores por nodo (en vez de 256 en main) y una capacidad RAM de 187GB (en vez de 768GB en main). Puede ver más información de las particiones en este link(agregar link), donde podrá revisar que con la inclusión de Guacolda hemos añadido nodos con hasta 765GB de memoria RAM y nodos con GPUs Nvidia Tesla V100 y AMD Instinct MI100 .<br />
<br />
Para ver los nodos disponibles y poder determinar en que partición lanzar los trabajos se recomienda utilizar el siguiente comando.<br />
<br />
<pre>[prueba@leftraru1 ~]$ sinfo -o "%10P %6D %10t %10m %c" -t idle| egrep "PARTITION|main|general|largemem|v100|mi100|mi210"<br />
PARTITION NODES STATE MEMORY CPUS<br />
PARTITION NODES STATE MEMORY CPUS<br />
main* 2 idle 727000 256<br />
general 0 n/a 0 0<br />
largemem 0 n/a 0 0<br />
v100 0 n/a 0 0<br />
mi100 1 idle 485000 128<br />
mi210 1 idle 1457000 48<br />
</pre><br />
<br />
El comando anterior muestra que main tiene 27 nodos libres, en este caso es recomendado lanzar en en main para evitar que el trabajo quede en cola por falta de recursos en otros nodos.<br />
<br />
Otro Ejemplo, se muestra sólo una partición específica<br />
<br />
<pre>[prueba@leftraru1 ~]$ sinfo -p main<br />
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST<br />
main* up infinite 15 mix mn[001-008,014-020]<br />
main* up infinite 12 idle mn[009-013,021-027]<br />
</pre><br />
<br />
=== Comprobación del estado de tareas ===<br />
squeue - Muestra el estatus de los trabajos<br />
<br />
<pre>squeue # tus trabajos<br />
squeue -u &lt;username&gt; # trabajos por usuario &lt;username&gt;<br />
</pre><br />
<br />
squeue: Comprobar estados de los trabajos<br />
<br />
<div style="" class="mw-highlight mw-content-ltr" dir="ltr"><br />
<pre><br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
13951858_1 general test1 test1 R 1-18:35:14 2 cn[009-010]<br />
13951857_2 general test2 test1 R 1-18:36:11 2 cn[099-100]<br />
13956453 gpu test3 test3 R 1-03:42:08 1 cn039<br />
13956449 largemem test4 test4 R 1-05:42:08 1 cn044<br />
</pre><br />
<br />
Puede utilizar squeue para saber el estado de una o varias de sus tareas<br />
<br />
<pre><br />
$ squeue -o "%.15i %.6P %.8j %.20S %.11M %.11L %.20V %.10Q %.4C %.2D %.6m" -S -t,-Q<br />
JOBID PARTIT NAME START_TIME TIME TIME_LEFT SUBMIT_TIME PRIORITY CPUS NO MIN_ME<br />
10837561 general TEST1 2018-06-18T18:51:01 19:00:31 2-04:59:29 2018-06-18T18:51:01 119972 1 1 1000M<br />
10838562 general TEST2 2018-06-19T11:30:47 2:20:45 2-21:39:15 2018-06-19T11:30:46 119946 1 1 1000M<br />
</pre><br />
<br />
<br />
para mas opciones puede revisar con el comando [https://slurm.schedmd.com/squeue.html man squeue] las opciones restantes.<br />
<br />
=== Códigos de ESTADO de los trabajos ===<br />
<br />
Los trabajos suelen pasar por varios estados durante su ejecución. Los estados típicos son PENDIENTE, EN EJECUCIÓN, SUSPENDIDO, FINALIZANDO y TERMINADO. A continuación se explica cada estado.<br />
<br />
'''BF''' BOOT_FAIL<br />
Trabajo finalizado debido a un fallo de arranque, normalmente debido a un fallo de hardware (por ejemplo, no se puede arrancar el nodo o bloque y el trabajo no se puede volver a poner en cola). <br />
<br />
'''CA''' CANCELADO<br />
El trabajo ha sido cancelado explícitamente por el usuario o el administrador del sistema. El trabajo puede haberse iniciado o no. <br />
<br />
'''CD''' TERMINADO<br />
El trabajo ha terminado todos los procesos en todos los nodos con un código de salida de cero. <br />
<br />
'''CF''' CONFIGURANDO<br />
Al trabajo se le han asignado recursos, pero están esperando a que estén listos para su uso (por ejemplo, arrancando). <br />
<br />
'''CG''' COMPLETANDO<br />
El trabajo está en proceso de finalización. Algunos procesos en algunos nodos pueden estar aún activos. <br />
<br />
'''DL''' FECHA LÍMITE<br />
El trabajo ha finalizado en la fecha límite. <br />
<br />
'''F''' FALLÓ<br />
Trabajo finalizado con un código de salida distinto de cero u otra condición de fallo. <br />
<br />
'''NF''' NODO_FAIL<br />
Trabajo finalizado debido al fallo de uno o más nodos asignados. <br />
<br />
'''OOM''' OUT_OF_MEMORY<br />
El trabajo ha experimentado un error de memoria insuficiente. <br />
<br />
'''PD''' PENDIENTE<br />
El trabajo está pendiente de asignación de recursos. <br />
<br />
'''PR''' PREEMPTED<br />
El trabajo ha finalizado debido a una espera. <br />
<br />
'''R''' EN MARCHA<br />
El trabajo tiene actualmente una asignación. <br />
<br />
'''RD''' RESV_DEL_HOLD<br />
El trabajo se está reteniendo después de que se eliminara la reserva solicitada. <br />
<br />
'''RF''' REQUEUE_FED<br />
El trabajo está siendo solicitado por una federación. <br />
<br />
'''RH''' REQUEUE_HOLD<br />
Se está volviendo a poner en cola un trabajo retenido. <br />
<br />
'''RQ''' REQUEUED<br />
Se está poniendo en cola un trabajo que se está completando. <br />
<br />
'''RS''' CAMBIO DE TAMAÑO<br />
El trabajo está a punto de cambiar de tamaño. <br />
<br />
'''RV''' REVOCADO<br />
El trabajo se ha retirado del clúster debido a que otro clúster ha iniciado el trabajo. <br />
<br />
'''SI''' SEÑALANDO<br />
El trabajo está siendo señalizado. <br />
<br />
'''SE''' SPECIAL_EXIT<br />
El trabajo se ha puesto en cola en un estado especial. Este estado puede ser establecido por los usuarios, normalmente en EpilogSlurmctld, si el trabajo ha terminado con un valor de salida particular. <br />
<br />
'''SO''' STAGE_OUT<br />
El trabajo está preparando los archivos. <br />
<br />
'''ST''' PARADO<br />
El trabajo tiene una asignación, pero la ejecución se ha detenido con la señal SIGSTOP. Los CPUS han sido retenidos por este trabajo. <br />
<br />
'''S''' SUSPENDIDO<br />
El trabajo tiene una asignación, pero se ha suspendido la ejecución y se han liberado CPUs para otros trabajos. <br />
<br />
'''TO''' TIMEOUT<br />
El trabajo ha finalizado al alcanzar su límite de tiempo.<br />
<br />
=== Cancelar un trabajo ===<br />
Con scancel se puede cancelar un trabajo en ejecución<br />
<pre>scancel &lt;jobID&gt; # Matar proceso &lt;jobID&gt;. (puede obtener el ID del job con "squeue")<br />
scancel -u &lt;username&gt; # Matar proceso por usuario &lt;username&gt;. <br />
</pre><br />
<pre>[prueba@leftraru1 ~]$ squeue -u prueba<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
45594 main TEST prueba R 0:59 3 mn[001-003]<br />
</pre><br />
<pre>[prueba@leftraru1 ~]$ scancel 45594<br />
[prueba@leftraru1 ~]$ squeue -u prueba<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
[prueba@leftraru1 ~]$<br />
</pre><br />
<br />
=== Ver estado de trabajos ===<br />
Para revisar el detalle de las opciones de un trabajo: scontrol show job<br />
<br />
<pre><br />
$ scontrol show job 10837561<br />
JobId=10837561 JobName=TEST1<br />
UserId=usuario(1000) GroupId=group(1000) MCS_label=N/A<br />
Priority=1100 Nice=0 Account=account QOS=120<br />
JobState=RUNNING Reason=None Dependency=(null)<br />
Requeue=0 Restarts=0 BatchFlag=1 Reboot=0 ExitCode=0:0<br />
DerivedExitCode=0:0<br />
RunTime=19:03:08 TimeLimit=3-00:00:00 TimeMin=N/A<br />
SubmitTime=2018-06-18T18:51:01 EligibleTime=2018-06-18T18:51:01<br />
StartTime=2018-06-18T18:51:01 EndTime=2018-06-21T18:51:01 Deadline=N/A<br />
PreemptTime=None SuspendTime=None SecsPreSuspend=0<br />
Partition=main AllocNode:Sid=leftraru2:5471<br />
ReqNodeList=(null) ExcNodeList=(null)<br />
NodeList=cn021<br />
BatchHost=cn021<br />
NumNodes=1 NumCPUs=1 NumTasks=1 CPUs/Task=1 ReqB:S:C:T=0:0:*:*<br />
TRES=cpu=1,mem=1000M,node=1<br />
Socks/Node=* NtasksPerN:B:S:C=1:0:*:* CoreSpec=*<br />
Nodes=cn021 CPU_IDs=1 Mem=1000 GRES_IDX=<br />
MinCPUsNode=1 MinMemoryCPU=1000M MinTmpDiskNode=0<br />
Features=(null) DelayBoot=00:00:00<br />
Gres=(null) Reservation=(null)<br />
OverSubscribe=OK Contiguous=0 Licenses=matlab Network=(null)<br />
Command=/home/usuario/script.sh<br />
WorkDir=/home/usuario/<br />
StdErr=/home/usuario/10837561_%x.err<br />
StdIn=/dev/null<br />
StdOut=/home/usuario/10837561_%x.out<br />
Power=<br />
BatchScript=<br />
</pre><br />
<br />
Para ver el script asociado a un trabajo: scontrol write batch_script <job_id> -<br />
<br />
<pre><br />
$ scontrol write batch_script 10837561 -<br />
#!/bin/bash<br />
#SBATCH -J nombre_del_trabajo<br />
#SBATCH -p main<br />
#SBATCH -n 1<br />
#SBATCH --ntasks-per-node=1<br />
#SBATCH --mail-user=usaurio@correo.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o nombre_del_trabajo%j_%x.out<br />
#SBATCH -e nombre_del_trabajo%j_%x.err<br />
#SBATCH --license=matlab <br />
<br />
ml MATLAB/2017a<br />
<br />
matlab -nodisplay -nosplash -nodesktop < programa.m<br />
</pre><br />
<br />
== Ejecutando trabajos ==<br />
Actualmente contamos con 2 metodos de enviar trabajos bajo SLURM: '''sbatch''' and '''srun'''. A veces puede ser ventajoso ejecutar un solo comando en el clúster como prueba o realizar rápidamente una operación con recursos adicionales. 'srun' permite a los usuarios hacer esto, y comparte las mismas variables que 'sbatch' . STDOUT y STDERR para un trabajo 'srun' serán redirigidos a la pantalla del usuario. Ctrl-C cancelará un trabajo srun. '''sbatch''' enviará un script de trabajo para que lo ejecute el clúster. Los scripts de trabajo bajo SLURM son simplemente scripts de shell (* .sh) con un conjunto de solicitudes de recursos en la parte superior del script.<br />
<br />
<br />
Uso básico de srun:<br />
<br />
<pre><br />
srun <algúnComando><br />
</pre><br />
<br />
<br />
Ejemplo de salida (ejecutando el comando "hostname" para saber en que nodo se está ejecutando):<br />
<pre> $ srun hostname<br />
cn003<br />
</pre><br />
<br />
<br />
Para enviar un script de trabajo a SLURM:<br />
<pre>sbatch nombreScript.sh</pre><br />
<br />
<br />
Example output:<br />
<pre>$ sbatch test-job.sh<br />
Submitted batch job 1169</pre><br />
<br />
=== Variables Slurm ===<br />
Las variables en esta sección son obligatorias, y SLURM las determina para determinar dónde y cuándo se ejecutarán sus trabajos. Si no asigna un valor para estos, el planificador asignará a sus trabajos el valor predeterminado. Si no solicita específicamente recursos para un trabajo, se le asignará un conjunto de recursos predeterminados. Para obtener una lista de todas las variables disponibles, consulte la documentación de SLURM en http://slurm.schedmd.com/sbatch.html. Las variables de este artículo estaban cubiertas porque eran las más relevantes para los casos de uso típicos.<br />
<br />
<table class="wikitable" style="width: 100%;"><br />
<tr><br />
<td><b>Comando SLURM</b></td><br />
<td><b>Descripción</b><br />
</td></tr><br />
<tr><br />
<td>--mem-per-cpu=&lt;megabytes&gt;</td><br />
<td>Memoria requerida para el trabajo por CPU (en MegaBytes). El valor predeterminado es 1024 MB.<br />
</td></tr><br />
<tr><br />
<td>-p &lt;partition&gt;, --partition=&lt;partition&gt;</td><br />
<td>Enviar un trabajo a una partición específica.<br />
</td></tr><br />
<tr><br />
<td>-n, --ntasks=&lt;cantidad de tareas&gt;</td><br />
<td>Número de tareas que serán asignadas para el trabajo.<br />
</td></tr><br />
<tr><br />
<td>-c &lt;cpus&gt;</td><br />
<td>Esta es la cantidad de CPU que necesita su trabajo. Tenga en cuenta que SLURM es relativamente generoso con las CPU, y el valor especificado aquí es el número "mínimo" de CPU que se asignará a su trabajo. Si hay CPU adicionales disponibles en un nodo más allá de lo solicitado, su trabajo recibirá esas CPU hasta que otros trabajos las necesiten. El valor predeterminado es 1 CPU. Intentar usar más CPU de las que se le asignaron dará como resultado que sus procesos adicionales se turnen en la misma CPU (ralentizando su trabajo).<br />
</td></tr><br />
<tr><br />
<td>-J &lt;name&gt;, --jobname=&lt;name&gt;</td><br />
<td>Especifica un nombre a tu trabajo.<br />
</td></tr><br />
<tr><br />
<td>--mail-type=BEGIN,END,FAIL,ALL<b> and </b>--mail-user=&lt;emailAddress&gt;</td><br />
<td>Enviar por correo electrónico cuando su trabajo comienza / termina / falla. Puede especificar varios valores para esto (separados por comas) si es necesario.<br />
</td></tr><br />
<tr><br />
<td>-o &lt;STDOUT_log&gt;, --output=&lt;STDOUT_log&gt;</td><br />
<td>Redirija la salida a los archivos de registro que especifique. Por defecto, ambos, STDOUT and STDERR son enviados a este archivo. Puedes especificar %j como parte del nombre de archivo de registro para indicar la ID del trabajo (como ejemplo, "#SBATCH -o ouptut_%j.o" redirigiría la salida a "output_123456.o").<br />
</td></tr><br />
<tr><br />
<td>-e &lt;STDERR_log&gt;, --error=&lt;STDERR_log&gt;</td><br />
<td>Redireccionar STDERR a un archivo separado. Funciona exactamente igual que "-o".<br />
</td></tr><br />
<tr><br />
<td>-t &lt;days-hours:minutes:seconds&gt;</td><br />
<td>Walltime para tu trabajo. La duración del Walltime es el tiempo que espera que su trabajo se ejecute.<br />
</td></tr><br />
<tr><br />
<td>-a, --array=&lt;índices&gt;</td><br />
<td>Envía una lista (arreglo) de trabajos identicos. Solo aplica para sbatch.<br />
</td></tr></table><br />
<br />
<br />
Los scripts de trabajo especifican los recursos solicitados y otras consideraciones especiales con comentarios especiales "#SBATCH" en la parte superior de un script de trabajo. Aunque muchas de estas opciones son opcionales, las varibles que se ocupan de solicitudes de recursos (CPU, memoria y tiempo) son obligatorias. Todas las variables deben agregarse a sus scripts de la siguiente manera:<br />
<br />
<pre>#SBATCH <variable></pre><br />
Para especificar un nombre al job, por ejemplo, debe agregar lo siguiente a su secuencia de comandos:<br />
<br />
<pre>#SBATCH --job-name=nombreDeTrabajo</pre><br />
<br />
===Enviar un script===<br />
<pre> <br />
#!/bin/bash<br />
#SBATCH -J example<br />
#SBATCH -p general<br />
#SBATCH -n 1<br />
#SBATCH --output=example_%j.out<br />
#SBATCH --error=example_%j.err<br />
#SBATCH --mail-user=user@example.com<br />
#SBATCH --mail-type=ALL<br />
</pre><br />
<br />
Como debe comenzar un script en Linux:<br />
<pre><br />
#!/bin/bash<br />
</pre><br />
<br />
<br />
Nombre del trabajo:<br />
<pre><br />
#SBATCH -J example<br />
</pre><br />
<br />
<br />
Nombre la partición donde desea ejecutar el Job:<br />
<pre><br />
#SBATCH -p general<br />
</pre><br />
<br />
<br />
Número de tareas:<br />
<pre><br />
#SBATCH -n 1<br />
</pre><br />
<br />
<br />
Log de salida:<br />
<pre><br />
#SBATCH -o example_%j.out<br />
</pre><br />
<br />
<br />
Log de error:<br />
<pre><br />
#SBATCH -e example_%j.err<br />
</pre><br />
<br />
<br />
Correo para notificaciones:<br />
<pre><br />
#SBATCH --mail-user=user@example.com<br />
</pre><br />
<br />
<br />
Enviar correo en todos casos (verificar opciones arriba):<br />
<pre><br />
#SBATCH --mail-type=ALL<br />
</pre><br />
<br />
=== Programar tarea (uso de scrontab) ===<br />
'''scrontab''' es una implementación del clásico planificador de tareas de linux '''crontab''' donde se guarda un listado de comandos a ejecutar en un tiempo determinado por el usuario.<br />
<br />
Para acceder a scrontab utilice el siguiente comando:<br />
<pre><br />
[prueba@leftraru1 ~]$ scrontab -e<br />
</pre><br />
<br />
Esto le permitirá editar su archivo scrontab, asignando recursos como también el momento en que desea ejecutar su tarea. La estructura base a utilizar es la siguiente:<br />
<pre><br />
#SCRON -J mi_tarea<br />
#SCRON -p main<br />
#SCRON -n 1<br />
#SCRON -c 1<br />
#SCRON --mem-per-cpu=2300<br />
#SCRON --mail-user=foo@bar.com<br />
#SCRON --mail-type=ALL<br />
#SCRON -o mi_tarea_%j.out<br />
#SCRON -e mi_tarea_%j.err<br />
# Example of job definition:<br />
# .---------------- minute (0 - 59)<br />
# | .------------- hour (0 - 23)<br />
# | | .---------- day of month (1 - 31)<br />
# | | | .------- month (1 - 12) OR jan,feb,mar,apr ...<br />
# | | | | .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat<br />
# | | | | |<br />
# * * * * * command to be executed<br />
</pre><br />
<br />
* '''minute''' - Corresponde al minuto en que se va a ejecutar el script, valor de 0 a 59.<br />
* '''hour''' - Hora de ejecución, formato 24 horas, valor de 0 a 23, donde 0 son las 12:00 AM.<br />
* '''day of month''' - Día del mes, la tarea se puede ejecutar cada x día, valor de 1 a 31.<br />
* '''month''' - La tarea se puede ejecutar cada x mes, valor de 1 a 12.<br />
* '''day of week''' - Día de la semana, valor de 0 a 6, donde 0 es Domingo.<br />
* '''command to be executed''' - Script a ejecutar por el usuario.<br />
<br />
Ejemplo envío de trabajo slurm:<br />
<br />
Para la asignación de recursos, utilizaremos la directriz '''#SCRON''', que utiliza los mismos parámetros usados por '''#SBATCH'''.<br />
<br />
Luego de asignar los recursos debemos especificar el tiempo, en este caso la tarea será ejecutada todos los días cada 20 minutos, luego debemos indicar el script enviado por el usuario y guardamos los cambios en el archivo.<br />
<br />
<pre><br />
*/20 * * * * /home/prueba/ejemplo/script.sh<br />
</pre><br />
<br />
Es importante destacar que el script a lanzar '''/home/prueba/ejemplo/script.sh''' debe tener permisos de ejecución.<br />
<br />
Para revisar el listado de tareas existentes en nuestro scrontab, ejecutamos el comando:<br />
<pre><br />
[prueba@leftraru1 ~]$ scrontab -l<br />
*/20 * * * * /home/prueba/ejemplo/script.sh<br />
</pre><br />
<br />
<br />
Para borrar el contenido de nuestro scrontab:<br />
<pre><br />
[prueba@leftraru1 ~]$ scrontab -r<br />
</pre><br />
<br />
'''Información a considerar:'''<br />
<br />
* Generar archivos de salida correctamente<br />
** Para que el archivo error y out de tu script se generen en el directorio solicitado, ejemplo, /home/prueba/ejemplo/ en tu script debe estar presente el comando cd “/home/prueba/ejemplo”, esto hará que scrontab se posicione dentro del directorio de salida.<br />
* Es distinto el tiempo de programar el envío de una tarea (scrontab) a que una tarea inicie en el clúster (running), ya que esto dependerá de los recursos libres que existan en ese momento en el clúster.<br />
* Para revisar las tareas programadas debe ejecutar en cualquier nodo login el comando '''scrontab -l''' o revisar con el comando '''squeue''':<br />
<br />
<pre><br />
[prueba@leftraru1 ~]$ squeue<br />
24293471 main /home/eg prueba PD 0:00 1 (BeginTime)<br />
</pre><br />
<br />
== Checkpointing ==<br />
Es la acción de guardar el estado de un proceso en ejecución en un archivo de imagen de punto de control. Este proceso se puede reiniciar más tarde desde el archivo del punto de control, continuando la ejecución desde donde se detuvo, en la misma computadora o en una diferente.<br />
<br />
=== ¿Por qué utilizarlo? ===<br />
* Permite ejecuciones de tarea largas que superen el tiempo de ejecución permitido en el cluster (30 días)<br />
* Estar preparados ante fallas del sistema que nos puedan hacer perder resultados de nuestras simulaciones<br />
<br />
=== Utilización ===<br />
Lo primero que debemos hacer en nuestro script es cargar el módulo de Mana:<br />
<pre><br />
ml mana/3.0.0<br />
</pre><br />
Este módulo provee 3 ejecutables que necesitaremos:<br />
<br />
* '''mana_coordinator:''' Coordina los checkpoints entre los distintos procesos<br />
* '''mana_launch:''' Inicia un proceso con checkpoint<br />
* '''mana_restart:''' Reinicia la ejecución desde una imagen del checkpoint<br />
<br />
Necesitaremos 2 scripts para trabajar con checkpoints: Inicio y reinicio<br />
<br />
=== Script de inicio (inicio.sh) ===<br />
<pre><br />
#!/bin/bash<br />
##---------------SLURM Parameters - NLHPC ----------------<br />
#SBATCH -J Testcheckpoint<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4363<br />
#SBATCH --mail-user=test@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o Testcheckpoint_%j.out<br />
#SBATCH -e Testcheckpoint_%j.err<br />
<br />
# ----------------Modules----------------------------<br />
ml mana/3.0.0<br />
# ----------------Command--------------------------<br />
#Checkpointing cada 1 hora<br />
mana_cooridinator -i3600<br />
#Ejecutamos nuestra tarea con checkpointing<br />
srun mana_launch ./ejecutable<br />
</pre><br />
<br />
=== Script de reinicio (reinicio.sh) ===<br />
<pre><br />
#!/bin/bash<br />
##---------------SLURM Parameters - NLHPC ----------------<br />
#SBATCH -J Testcheckpoint<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4363<br />
#SBATCH --mail-user=test@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o Testcheckpoint_%j.out<br />
#SBATCH -e Testcheckpoint_%j.err<br />
<br />
# ----------------Modules----------------------------<br />
ml mana/3.0.0<br />
# ----------------Command--------------------------<br />
#Checkpointing cada 1 hora<br />
mana_cooridinator -i3600<br />
#Reiniciar nuestra tarea desde los archivos de checkpoint<br />
srun mana_restart<br />
</pre> <br />
<br />
<br />
Para correr estos scripts se puede hacer utilizando la funcionalidad de dependencias de SLURM:<br />
<pre><br />
[test@leftraru2 test]$ sbatch inicio.sh<br />
Submitted batch job 23574685<br />
[test@leftraru2 test]$ sbatch --dependency=afterok:23574685 reinicio.sh<br />
</pre><br />
<br />
== Trabajos ==<br />
=== Trabajos paralelos ===<br />
Muchos de los trabajos que se ejecutan en un clúster de producción implicarán más de un procesador (CPU, núcleo). Dichos trabajos paralelos deben solicitar la cantidad de recursos necesarios a través de opciones adicionales. Los más comunes son:<br />
<br />
Para diferentes tipos de trabajos paralelos, se especificarán diferentes opciones. Los trabajos paralelos más comunes son trabajos de MPI (memoria distribuida), trabajos de subprocesos múltiples (memoria compartida) y los llamados híbridos que son una combinación de los dos. Analicemos por separado con un n ejemplo para cada uno.<br />
<br />
=== Ejecución de programas con MPI ===<br />
MPI (interfaz de paso de mensajes) es la API de comunicación estándar para trabajos paralelos de memoria distribuida capaz de implementarse en un clúster. Para programar dicho trabajo, es necesario especificar la cantidad de nodos del clúster que se utilizarán y la cantidad de procesos (tareas) que se ejecutarán en cada nodo.<br />
<br />
El siguiente es un ejemplo de ejecución de un programa compilado con Open MPI:<br />
<br />
#!/bin/bash<br />
#SBATCH -J example_mpi<br />
#SBATCH -p general<br />
#SBATCH -n 264<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --output=example_%j.out<br />
#SBATCH --error=example_%j.err<br />
#SBATCH --mail-user=user@example.com<br />
#SBATCH --mail-type=ALL<br />
<br />
srun ./mpi_test<br />
A continuacion se explica línea por líneael script.<br />
<br />
Como empieza un shell script en Linux:<br />
<pre><br />
#!/bin/bash<br />
</pre><br />
<br />
<br />
Nombre del Job:<br />
<pre><br />
#SBATCH -J example_mpi<br />
</pre><br />
<br />
<br />
Nombre la particion donde se desea ejecutar el trabajo:<br />
<pre><br />
#SBATCH -p general<br />
</pre><br />
<br />
<br />
Número de tareas. Debe de ser un número múltiplo del número de CPUs máximo que tenga un node de la partición donde se lanza:<br />
<pre><br />
#SBATCH -n 264<br />
</pre><br />
<br />
<br />
Con esto se fuerza a que se lancen 44 tareas MPI en cada uno de los nodos, ocupando de este modo nodos completos. En este caso 6 nodos completos:<br />
<pre><br />
#SBATCH --ntasks-per-node=44<br />
</pre><br />
<br />
<br />
Log de salida:<br />
<pre><br />
#SBATCH -o example_%j.out<br />
</pre><br />
<br />
<br />
Log de error:<br />
<pre><br />
#SBATCH -e example_%j.err<br />
</pre><br />
<br />
<br />
Correo para notificaciones:<br />
<pre><br />
#SBATCH --mail-user=user@example.com<br />
</pre><br />
<br />
<br />
Envía correo en todos los casos:<br />
<pre><br />
#SBATCH --mail-type=ALL<br />
</pre><br />
<br />
<br />
Programa para ejecutar:<br />
<pre><br />
srun ./mpi_test<br />
</pre><br />
<br />
'''Nota''': no se carga específicamente el módulo "mpi" ya que se carga siempre por defecto.<br />
<br />
Para enviarlo al clúster debe ejecutar el comando: ''sbatch script.sh''. El ejemplo anterior ejecutará una tarea OpenMPI con 264 procesos reservando 264 cores para ello.<br />
<br />
=== Trabajos multiproceso OpenMP ===<br />
Los trabajos paralelos diseñados para ejecutarse en un sistema multi-core (shared-memory) suelen ser "multi-threaded". La programación de un job de este tipo requiere especificar el número de núcleos que se utilizan para acomodar los subprocesos.<br />
<br />
OpenMP es el conjunto común de variables de compilación para facilitar el desarrollo de programas multi-threaded. Un script típico de SLURM para un programa de este tipo se ve así:<br />
<pre><br />
#!/bin/bash<br />
#SBATCH -J OMPtest<br />
#SBATCH -p general<br />
#SBATCH -n 1<br />
#SBATCH -c 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=1024<br />
#SBATCH -o example_%j.out<br />
#SBATCH -e example_%j.err<br />
#SBATCH --mail-user=user@example.com<br />
#SBATCH --mail-type=ALL<br />
<br />
OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK time ./omp-program<br />
</pre><br />
<br />
<br />
Como debe comenzar un script en Linux:<br />
<pre><br />
#!/bin/bash<br />
</pre><br />
<br />
<br />
Nombre del Job:<br />
<pre><br />
#SBATCH -J OMPtest<br />
</pre><br />
<br />
<br />
Nombre la particion donde desea ejecutar el Job:<br />
<pre><br />
#SBATCH -p general<br />
</pre><br />
<br />
<br />
Número de trabajos:<br />
<pre><br />
#SBATCH -n 1<br />
</pre><br />
<br />
<br />
Número de tareas:<br />
<pre><br />
#SBATCH -c 44<br />
</pre><br />
<br />
<br />
Con esto se fuerza a que se agrupen las 44 tareas en un nodo (en OpenMP no hay comunicación entre nodos, por lo que todas las tareas deben estar en el mismo nodo o no funcionaría):<br />
<pre><br />
#SBATCH --ntasks-per-node=44<br />
</pre><br />
<br />
<br />
Memoria por core (MBytes):<br />
<pre><br />
#SBATCH --mem-per-cpu=1024<br />
</pre><br />
<br />
<br />
Log de salida:<br />
<pre><br />
#SBATCH -o example_%j.out<br />
</pre><br />
<br />
<br />
Log de error:<br />
<pre><br />
#SBATCH -e example_%j.err<br />
</pre><br />
<br />
<br />
Correo para notificaciones:<br />
<pre><br />
#SBATCH --mail-user=user@example.com<br />
</pre><br />
<br />
<br />
Enviar correo en todos los casos:<br />
<pre><br />
#SBATCH --mail-type=ALL<br />
</pre><br />
<br />
<br />
Programa para ejecutar:<br />
<pre><br />
OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK time ./omp-program <br />
</pre><br />
<br />
<br />
Cuando se utiliza un programa OpenMP, el número de subprocesos (y, por lo tanto, el número requerido de núcleos) se especifica a través de la variable de entorno OMP_NUM_THREADS que, por lo tanto, aparece en el script frente a la llamada al programa. Lo estamos configurando en la variable interna SLURM_CPUS_PER_TASK que se establece a través de la opción "-c" (a 44 en nuestro ejemplo, que sería el número total de cores de un nodo de la partición "general").<br />
<br />
La opción "-n" se mantiene en 1 para indicar un único trabajo principal que tiene 44 tareas. Para asegurarnos que todas las tareas se ejecutan en el mismo nodo, se añade la opción "--ntasks-per-node" con el máximo número de cores que tiene un nodo de la partición donde se está lanzando el trabajo.<br />
<br />
=== Ejecución de tareas en GPUs ===<br />
<pre><br />
#!/bin/bash<br />
#SBATCH -J ejemplo_gpus<br />
#SBATCH -p v100<br />
#SBATCH -n 1<br />
#SBATCH -o ejemplo_%j.out<br />
#SBATCH -e ejemplo_%j.err<br />
#SBATCH --mail-user=correo@gmail.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH --mem-per-cpu=4300<br />
#SBATCH --gres=gpu:1<br />
<br />
./programa<br />
</pre><br />
<br />
<br />
Inicio de un bash script en Linux:<br />
<pre><br />
#!/bin/bash<br />
</pre><br />
<br />
<br />
Nombre del trabajo:<br />
<pre><br />
#SBATCH -J ejemplo_gpus<br />
</pre><br />
<br />
<br />
Nombre la partición donde se ejecuta el trabajo:<br />
<pre><br />
#SBATCH --partition=v100<br />
</pre><br />
<br />
<br />
Número de tareas:<br />
<pre><br />
#SBATCH -n 1<br />
</pre><br />
<br />
<br />
Log de salida:<br />
<pre><br />
#SBATCH -o ejemplo_%j.out<br />
</pre><br />
<br />
<br />
Log de error:<br />
<pre><br />
#SBATCH -e ejemplo_%j.err<br />
</pre><br />
<br />
<br />
Correo para notificaciones:<br />
<pre><br />
#SBATCH --mail-user=user@example.com<br />
</pre><br />
<br />
<br />
Enviar correo en todos los casos:<br />
<pre><br />
#SBATCH --mail-type=ALL<br />
</pre><br />
<br />
<br />
Memoria por CPU (MB):<br />
<pre><br />
#SBATCH --mem-per-cpu=4365<br />
</pre><br />
<br />
<br />
Cantidad utilizada de GPUs. El parámetro gpu:1 indica la cantidad de tarjetas a utilizar (cada nodo tiene 2 GPUs):<br />
<pre><br />
#SBATCH --gres=gpu:1<br />
</pre><br />
<br />
<br />
Programa para ejecutar:<br />
<pre><br />
./programa<br />
</pre><br />
<br />
=== Job Arrays ===<br />
Cuando se ejecutan cientos o miles de simulaciones que utilizan la misma cantidad de recursos, puede ser una ventaja ejecutar estas simulaciones como un "job array". Los job array le permiten enviar miles de dichos trabajos (llamados "job steps") con un solo script. A cada simulación se le asignará un valor único para la variable de entorno SLURM_ARRAY_TASK_ID. Puede usar esta variable para leer parámetros para pasos individuales de una línea dada de un archivo.<br />
<br />
=== Caso de uso de un Script Job Array (Gaussian) ===<br />
Tenemos usuarios que actualmente envían varias simulaciones al clúster que son similares en cuanto al uso de recursos, pero, la diferencia es que solo cambia la entrada que le entregan al programa. Para esta situación, recomendamos hacer uso de un script Job Array.<br />
<br />
En este ejemplo crearemos un script job array para el software Gaussian, el cual, realizará 63 simulaciones, cada una de estas utilizará 8 cores y podrá alcanzar un uso máximo de 8 Gb de memoria ram. Para este caso utilizaremos la partición general donde cada nodo tiene 46 Gb de memoria ram y 20 cores.<br />
<br />
Script:<br />
<pre><br />
#!/bin/bash<br />
# ----------------SLURM Parameters----------------<br />
#SBATCH -J prueba<br />
#SBATCH -p general<br />
#SBATCH -n 1<br />
#SBATCH -c 8<br />
#SBATCH --mem-per-cpu=1000<br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH --array=1-63<br />
#SBATCH -o prueba_%A_%a.out<br />
#SBATCH -e prueba_%A_%a.err<br />
#-----------------Toolchain---------------------------<br />
ml purge<br />
ml intel/2019b<br />
# ----------------Módulos-----------------------------<br />
ml g16/B.01<br />
# ----------------Comandos--------------------------<br />
file=$(ls Child_10_*.com | sed -n ${SLURM_ARRAY_TASK_ID}p)<br />
srun g16 $file<br />
</pre><br />
<br />
'''<br />
Descripción de comandos utilizados en script:'''<br />
<br />
Inicio de un bash script en Linux:<br />
<pre><br />
#!/bin/bash<br />
</pre><br />
<br />
<br />
Nombre de la simulación:<br />
<pre><br />
#SBATCH -J prueba<br />
</pre><br />
<br />
<br />
Nombre la partición donde se ejecuta la simulación:<br />
<pre><br />
#SBATCH -p general<br />
</pre><br />
<br />
<br />
Número de tareas (1 tarea va a ejecutar 63 simulaciones):<br />
<pre><br />
#SBATCH -n 1<br />
</pre><br />
<br />
<br />
Core’s por tareas (cada tarea utilizará un máximo 8 cores):<br />
<pre><br />
#SBATCH -c 8<br />
</pre><br />
<br />
<br />
Memoria ram por cpu (cada tarea utilizará un máximo 8 Gb de ram):<br />
<pre><br />
#SBATCH –mem-per-cpu=1000<br />
</pre><br />
<br />
<br />
Correo para activar el envío de notificaciones:<br />
<pre><br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
</pre><br />
<br />
<br />
Permitir envío de notificaciones:<br />
<pre><br />
#SBATCH --mail-type=ALL<br />
</pre><br />
<br />
<br />
Se generan 63 simulaciones diferentes:<br />
<pre><br />
#SBATCH --array=1-63<br />
</pre><br />
<br />
<br />
Log de salida: (ejemplo: prueba_18455017_1.out)<br />
<br />
* %A corresponde al Job ID de nuestra tarea que le asignará Slurm → 18455017.<br />
* %a corresponde a la simulación X de nuestra tarea que le asignará Slurm → 1.<br />
<pre><br />
#SBATCH -o prueba_%A_%a.out<br />
</pre><br />
<br />
<br />
Log de errores: (ejemplo: prueba_18455017_1.err)<br />
<br />
* %A corresponde al Job ID de nuestra tarea que le asignará Slurm → 18455017.<br />
* %a corresponde a la simulación X de nuestra tarea que le asignará Slurm → 1.<br />
<br />
<pre><br />
#SBATCH -e prueba_%A_%a.err<br />
Toolchain: en este apartado, limpiaremos nuestro entorno de software no deseados y luego escogemos la herramienta informática con la cual está compilado el software Gaussian (nosotros utilizamos el compilador Intel/2019b).<br />
<br />
#-----------------Toolchain---------------------------<br />
ml purge<br />
ml intel/2019b<br />
Módulos: cargamos el software Gaussian versión 16/B.0.<br />
<br />
# ----------------Módulos-----------------------------<br />
ml g16/B.01<br />
Comandos: aquí definimos los comandos a ejecutar.<br />
<br />
# ----------------Comandos--------------------------<br />
file=$(ls Child_10_*.com | sed -n ${SLURM_ARRAY_TASK_ID}p)<br />
srun g16 $file<br />
</pre><br />
file= variable que va a listar los archivos de entrada que comiencen por Child_10_ y terminen en .com<br />
<br />
[[Archivo:Child.png|no]]<br />
<br />
<br />
sed -n ${SLURM_ARRAY_TASK_ID}p) ← Sed imprimirá las líneas de cada archivo de entrada y la variable $SLURM_ARRAY_TASK_ID asumirá estas entradas como matriz de simulación en nuestro job array, en este ejemplo tenemos 63 archivos de entrada.<br />
<br />
Para más detalles sobre los archivos stdin, stdout y stderr de una simulación % A será reemplazado por el valor de SLURM_ARRAY_JOB_ID que es el Job ID de nuestra tarea y %a será reemplazado por el valor de SLURM_ARRAY_TASK_ID que corresponde a la simulación X de nuestra tarea.<br />
<br />
Srun g16 $file: ejecutará el comando gaussian g16 interpretando la variable $file en los nodos de cómputo asignados.<br />
<br />
Enviar el script:<br />
<pre><br />
[prueba@leftraru1 ~]$ sbatch prueba.sh<br />
</pre><br />
<br />
=== Ejecución de una tarea que ocupa mucha RAM por CPU ===<br />
Debemos tener en cuenta que la RAM que SLURM reserva por defecto son 1000 MB. Un típico error de cancelación de tarea por falta de memoria es el siguiente:<br />
<pre><br />
/tmp/slurmd/job136839939/slurm_script: line 15: 23547 Killed ./programa.sh<br />
slurmstepd: error: Detected 1 oom-kill event(s) in step 136839939.batch cgroup. Some of your processes <br />
may have been killed by the cgroup out-of-memory handler.<br />
</pre><br />
<br />
<br />
Si su tarea ocupa más de la memoria por defecto, puede utilizar el siguiente parámetro:<br />
<pre><br />
#SBATCH --mem-per-cpu=2300 #Máxima RAM por CPU<br />
</pre><br />
Esto hará que SLURM reserve más RAM por CPU para sus tareas.<br />
<br />
Tenga en cuenta que nuestros nodos tienen 46 GB de memoria RAM (Partición slims), 187 GB (Partición general) y 765 GB (Partición largemem) por nodo. [https://wiki.nlhpc.cl/Hardware_Disponible Más información].<br />
<br />
Otra forma de reservar memoria es utilizando el siguiente parámetro:<br />
<br />
<pre><br />
#SBATCH --mem=2300<br />
</pre><br />
En este caso SLURM realizará una reserva de memoria de 2300 MB pero por la totalidad del trabajo.<br />
<br />
Los parámetros anteriores al igual que el número de CPUs que se van a usar, hay que afinarlos lo mejor posible. Para ello lo que se puede hacer es hacer pruebas en los nodos logins, sin lanzar en las colas, y así estudiar el uso de RAM y CPU por parte de sus procesos.<br />
<br />
=== Ejecución de una tarea con Dependencias ===<br />
Las dependencias de trabajos se utilizan para aplazar el inicio de un trabajo hasta que se satisfagan las dependencias especificadas. Se especifican con la opción --dependency en el siguiente formato:<br />
<pre><br />
sbatch --dependency=<type:job_id[:job_id][,type:job_id[:job_id]]> ...<br />
</pre><br />
Los tipos de dependencias son las siguientes:<br />
<br />
* '''after''':jobid[:jobid...] - el trabajo puede empezar después de que los trabajos especificados comiencen<br />
* '''afterany''':jobid[:jobid...] - el trabajo puede empezar después de que los trabajos especificados terminen<br />
* '''afternotok''':jobid[:jobid...] - el trabajo puede empezar después que los trabajos especificados terminan fallidamente<br />
* '''afterok''':jobid[:jobid...] - el trabajo puede empezar después que los trabajos especificados terminan exitósamente<br />
<br />
La manera más simple de usar una dependencia del tipo afterok:<br />
<pre><br />
[prueba@leftraru1 ~]$ sbatch job1.sh<br />
Submitted batch job 21363626<br />
[prueba@leftraru1 ~]$ sbatch --dependency=afterok:21363626 job2.sh<br />
</pre><br />
<br />
Ahora cuando job1.sh termine correctamente, el job2.sh entrará en ejecución. Si job1.sh termina fallidamente, job2.sh no entrará en ejecución nunca pero sí quedará en cola (debe cancelarse manualmente el trabajo).<br />
<br />
==== Capturando el Job ID para facilitar la ejecución de varias tareas con dependencias ====<br />
Es posible capturar en una variable el Job ID de cada tarea para poder lanzar varias tareas sin conocer el Job ID previamente.<br />
<br />
Por ejemplo, si se desea lanzar 4 tareas que sean dependientes con la anterior, se comenzará lanzando la primera tarea y capturando en la variable '''$JOB1''', el que será utilizado como dependencia en la tarea '''$JOB2''', y así sucesivamente.<br />
<br />
<pre><br />
JOB1=$(sbatch job_1.sbatch 2>&1 | awk '{print $4}')<br />
JOB2=$(sbatch --dependency=afterok:$JOB1 job_2.sbatch 2>&1 | awk '{print $4}')<br />
JOB3=$(sbatch --dependency=afterok:$JOB2 job_3.sbatch 2>&1 | awk '{print $4}')<br />
JOB4=$(sbatch --dependency=afterok:$JOB3 job_4.sbatch 2>&1 | awk '{print $4}')<br />
</pre><br />
<br />
== Prioridad de tarea ==<br />
Cómo ver la prioridad del trabajo. Los factores que determinan la prioridad del trabajo, incluyendo la fórmula y pesos.<br />
<br />
=== Factores que determinan prioridad de tarea ===<br />
<table class="wikitable" style="width: 60%;"><br />
<tr><br />
<td><b>Comando SLURM</b></td><br />
<td><b>Descripción</b><br />
</td></tr><br />
<tr><br />
<td>Edad</td><br />
<td>la cantidad de tiempo que el trabajo ha estado esperando en la cola.<br />
</td></tr><br />
<tr><br />
<td>Tamaño de la tarea</td><br />
<td>número de nodos solicitados por el trabajo.<br />
</td></tr><br />
<tr><br />
<td>Partición</td><br />
<td>prioridad para una partición determinada.<br />
</td></tr><br />
<tr><br />
<td>Prioridad Baja</td><br />
<td>Mientras más tareas se ejecuten en el cluster, menor será la prioridad.<br />
</td></tr><br />
<tr><br />
<td>Prioridad Alta</td><br />
<td>Mientras menos tareas se ejecuten en el clúster, más alta es la prioridad.<br />
</td></tr></table><br />
<br />
== Prioridad de tarea ==<br />
Cómo ver la prioridad del trabajo. Los factores que determinan la prioridad del trabajo, incluyendo la fórmula y pesos.<br />
<br />
=== Factores que determinan prioridad de tarea ===<br />
* Edad - la cantidad de tiempo que el trabajo ha estado esperando en la cola<br />
* Tamaño Oficio - número de nodos solicitados por el trabajo<br />
* Partición - prioridad para una partición determinada<br />
* Contribución de prioridades basada en los recursos informáticos utilizados por los miembros de un grupo de investigación en los últimos 30 días - Fairshare.<br />
* Mientras más tareas se ejecuten en el cluster, menor será la prioridad.<br />
* Mientras menos tareas se ejecuten en el clúster, más alta es la prioridad.<br />
Fórmula Prioridad de tarea<br />
<pre><br />
Job_priority =<br />
(PriorityWeightAge) * (age_factor) +<br />
(PriorityWeightFairshare) * (fair-share_factor) +<br />
(PriorityWeightJobSize) * (job_size_factor) +<br />
(PriorityWeightPartition) * (partition_factor) +<br />
(PriorityWeightQOS) * (QOS_factor)<br />
</pre><br />
<br />
== Visualización de sus Tareas ==<br />
Si Ud. necesita visualizar información acerca de sus tareas de forma interactiva, puede utilizar el comando smap:<br />
<br />
smap -i 3<br />
<br />
[[Archivo:Smap.png|no|700px]]<br />
<br />
<br />
De esta forma, tendrá una actualización cada 3 segundos de sus tareas en ejecución incluyendo los nodos en los cuales se encuentran ejecutándose.<br />
<br />
== Time Limit ==<br />
<br />
= Uso del parámetro <code>--time</code> (<code>-t</code>) en SLURM =<br />
<br />
El parámetro <code>--time</code> (o <code>-t</code>) en SLURM permite especificar el '''tiempo máximo de ejecución''' para un trabajo. Su uso correcto mejora la eficiencia del scheduler y permite aplicar estrategias como ''backfilling''.<br />
<br />
== Formato general ==<br />
<br />
<pre><br />
--time=D-HH:MM:SS<br />
</pre><br />
<br />
* '''D''': días (opcional)<br />
* '''HH''': horas (0–23)<br />
* '''MM''': minutos (0–59)<br />
* '''SS''': segundos (0–59)<br />
<br />
También puede usarse en formato corto con <code>-t</code>.<br />
<br />
== Ejemplos ==<br />
<br />
=== Trabajo de 1 hora ===<br />
<pre><br />
#SBATCH --time=01:00:00<br />
</pre><br />
<br />
o<br />
<br />
<pre><br />
#SBATCH -t 01:00:00<br />
</pre><br />
<br />
=== Trabajo de 4 horas y 30 minutos ===<br />
<pre><br />
#SBATCH --time=04:30:00<br />
</pre><br />
<br />
=== Trabajo de 2 días ===<br />
<pre><br />
#SBATCH --time=2-00:00:00<br />
</pre><br />
<br />
=== Trabajo de 15 minutos ===<br />
<pre><br />
#SBATCH --time=00:15:00<br />
</pre><br />
<br />
=== Trabajo de 3 días, 5 horas y 45 segundos ===<br />
<pre><br />
#SBATCH --time=3-05:00:45<br />
</pre><br />
<br />
== Ejemplo en script <code>job.sh</code> ==<br />
<br />
<pre><br />
#!/bin/bash<br />
#SBATCH --job-name=mi_trabajo<br />
#SBATCH --partition=general<br />
#SBATCH --ntasks=8<br />
#SBATCH --time=01:30:00 # 1 hora y 30 minutos<br />
#SBATCH --mem=16G<br />
<br />
srun ./mi_simulacion<br />
</pre><br />
<br />
== Recomendaciones ==<br />
<br />
* Estima lo mejor posible el tiempo necesario.<br />
* No omitas <code>--time</code>: si lo haces, SLURM asumirá un valor por defecto (como 5 días).<br />
* Para pruebas cortas, usa tiempos pequeños (por ejemplo, 10 minutos) para permitir el uso eficiente del scheduler mediante ''backfilling''.<br />
<br />
== Más información ==<br />
<br />
[https://slurm.schedmd.com/sbatch.html#OPT_time Documentación oficial de SLURM sobre el parámetro --time]<br />
<br />
== Bibliografía ==<br />
[http://slurm.schedmd.com/documentation.html Manual Oficial de Slurm]<br />
<br />
[https://slurm.schedmd.com/scrontab.html Documentación scrontab]</div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Apptainer&diff=801Apptainer2024-05-28T14:59:16Z<p>Eguerra: </p>
<hr />
<div>== ¿Qué es? ==<br />
Apptainer es un programa informático gratuito , multiplataforma y de código abierto que realiza la virtualización a nivel del sistema operativo, también conocida como containers.<br />
<br />
Uno de los principales usos de Apptainer es llevar contenedores y reproducibilidad a la informática científica y al mundo de la informática de alto rendimiento (HPC).<br />
<br />
Los contenedores de Apptainer se pueden usar para empaquetar flujos de trabajo científicos completos, software y bibliotecas, e incluso datos. Esto significa que no tiene que pedirle al administrador del clúster que instale nada por usted; puede ponerlo en un contenedor de Apptainer y ejecutarlo.<br />
<br />
El software Apptainer puede importar sus imágenes de Docker sin tener Docker instalado o ser un superusuario.<br />
<br />
¿Necesitas compartir tu código? Póngalo en un contenedor de Apptainer y su colaborador no tendrá que pasar por la molestia de instalar dependencias faltantes. ¿Necesita ejecutar un sistema operativo completamente diferente? Puede "cambiar" el sistema operativo de su host por otro diferente dentro de un contenedor de Apptainer<br />
<br />
== Modulos ==<br />
Para el uso de '''Apptainer''' debe cargar los módulos:<br />
<br />
* ml aocc/4.2.0<br />
* ml apptainer/1.3.1<br />
<br />
== Ejemplos de Lanzador ==<br />
=== Importar imagen de Apptainer ===<br />
Para este ejemplo utilizaremos la imagen de Apptainer hello-world (shub://singularityhub/hello-world), crearemos un directorio llamado Ejemplo y nos posicionaremos en el directorio creado:<br />
<pre><br />
prueba@leftraru1:~$ mkdir Ejemplo<br />
prueba@leftraru1:~$ cd Ejemplo/<br />
</pre><br />
<br />
Cargar módulo de Apptainer:<br />
<pre><br />
prueba@leftraru1:~$ ml purge<br />
prueba@leftraru1:~$ ml aocc/4.2.0<br />
prueba@leftraru1:~$ ml apptainer/1.3.1<br />
</pre><br />
<br />
Crear carpeta temporal:<br />
<pre><br />
prueba@leftraru1:~$ mkdir -p /tmp/singularityce/singularity/mnt/session<br />
</pre><br />
<br />
Importar imagen de Apptainer:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ apptainer pull shub://singularityhub/hello-world<br />
INFO: Downloading shub image<br />
59.75 MiB / 59.75 MiB [=====================================================================================================================================================] 100.00% 12.41 MiB/s 4s<br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 57344<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 10:46 hello-world_latest.sif<br />
</pre><br />
<br />
Ejecutando imagen:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ apptainer run hello-world_latest.sif<br />
INFO: Convert SIF file to sandbox...<br />
Tacotacotaco<br />
INFO: Cleaning up image...<br />
</pre><br />
<br />
Como se puede observar el resultado de ejecutar el contenedor es la palabra: '''Tacotacotaco'''<br />
<br />
=== Generando Script ===<br />
Ejemplo de script para lanzar en la partición general.<br />
<br />
Utilizamos 1 nodos, 44 simulaciones por nodo y utilizamos los 187 Gb de Ram declarados en el script:<br />
<br />
<pre>prueba@leftraru1:~/Ejemplo$ vim script_44cores.sh</pre><br />
<br />
Ejemplo de Script Slurm:<br />
<pre><br />
#!/bin/bash<br />
# ----------------SLURM Parameters----------------<br />
#SBATCH -J Hello-world<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4250<br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o hello-world_%j.out<br />
#SBATCH -e hello-world_%j.err<br />
<br />
#Modulos Necesarios<br />
ml aocc/4.2.0<br />
ml apptainer/1.3.1<br />
<br />
#Creación de carpeta<br />
mkdir -p /tmp/singularityce/singularity/mnt/session<br />
<br />
#Comandos<br />
srun apptainer run hello-world_latest.sif<br />
</pre><br />
<br />
Lanzar script:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ sbatch script_44cores.sh<br />
Submitted batch job 19051335<br />
</pre><br />
<br />
Revisar estado del trabajo:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
19051335 general Hello-wo prueba R 0:12 1 sn045<br />
</pre><br />
<br />
Revisar estado de simulación: (trabajo finalizado correctamente)<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
</pre><br />
<br />
<br />
Revisión de inicio del trabajo mediante correo:<br />
<br />
[[Archivo:Inicio Trabajo 19051335.jpg|no]]<br />
<br />
<br />
<br />
Revisión de finalización de trabajo mediante correo:<br />
<br />
[[Archivo:Finalización Trabajo 19051335.jpg|no]]<br />
<br />
<br />
La tarea fue ejecutada en 3 minutos con 04 segundos.<br />
<br />
Resultados de la tarea (se generan 2 archivos, 1 archivo error y un 1 archivo de salida):<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 61204<br />
-rw-r--r-- 1 prueba nlhpc 3872 Jul 30 11:31 hello-world_19051335.err<br />
-rw-r--r-- 1 prueba nlhpc 572 Jul 30 11:31 hello-world_19051335.out<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 11:16 hello-world_latest.sif<br />
-rwxr-xr-x 1 prueba nlhpc 405 Jul 30 11:30 script_44cores.sh<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.out:<br />
<br />
Aquí podemos ver que la ejecución nos entregó como resultado 44 veces la ejecución del contenedor (la simulación fue ejecutada de forma correcta).<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.out<br />
44 hello-world_19051335.out<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.out<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
...<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.err:<br />
<br />
Aquí podemos ver que Apptainer convirtió la imagen 44 veces y limpio la imagen 44 veces.<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.err<br />
88 hello-world_19051335.err<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.err<br />
Resumen<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Cleaning up image...<br />
INFO: Cleaning up image...<br />
<br />
<br />
</pre><br />
<br />
== Contenedores GPU AMD MI210 ==<br />
Contamos con un directorio especial que contiene una serie de imágenes listas para ser ejecutadas en las GPU AMD MI210. Basta con cargar el módulo de Apptainer:<br />
<br />
<pre> <br />
ml aocc/4.2.0<br />
ml apptainer/1.3.1 <br />
</pre><br />
<br />
<pre><br />
[modules@leftraru1 ~]$ ls $IMAGES<br />
chroma_3.43.0.sif nwchem.sif ryzen-ai-tensorflow2_latest.sif<br />
cp2k_2022.2.amd3.sif openfoam_2206.1.amd3.sif ryzen-ai-tensorflow_latest.sif<br />
grid_0.8.2-20211213.sif openmm_7.7.0_49.sif specfem3d_9c0626d1-20201122.sif<br />
gromacs_2022.3.amd1_174.sif petsc_3.18.amd4.sif specfem3d_globe_1ee10977-20210321.sif<br />
lammps_2022.5.04_130.sif pyfr_1.14.0_48.sif trilinos_1.7.sif<br />
namd_2.15a2-20211101.sif relion_4.0.sif uif-pytorch_uif1.2_rocm5.6.1_vai3.5_py3.8_pytorch1.13.sif<br />
namd3_3.0a9.sif ryzen-ai-pytorch_latest.sif uif-tensorflow_uif1.2_rocm5.6.1_vai3.5_tensorflow2.12.sif<br />
</pre><br />
<br />
=== Ejemplo contenedor CP2K ===<br />
<pre><br />
#!/bin/bash<br />
#---------------Script SBATCH - NLHPC ----------------<br />
#SBATCH -J testamd<br />
#SBATCH -p mi210<br />
#SBATCH -n 16<br />
#SBATCH --gres=gpu:1<br />
#SBATCH -c 4<br />
#SBATCH --mem-per-cpu=30354<br />
#SBATCH --mail-user=test@correo.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o testamd_%j.out<br />
#SBATCH -e testamd_%j.err<br />
<br />
#-----------------Toolchain---------------------------<br />
# ----------------Modulos----------------------------<br />
ml aocc/4.2.0<br />
ml apptainer/1.3.1<br />
# ----------------Comando--------------------------<br />
<br />
apptainer exec $IMAGES/cp2k_2022.2.amd3.sif mpirun -x NUM_CPUS=64 -x NUM_GPUS=6 -x RANK_STRIDE=6 -x OMP_NUM_THREADS=4 --oversubscribe -np 16 --bind-to none set_cpu_affinity.sh set_gpu_affinity.sh cp2k.psmp -i /opt/cp2k/benchmarks/QS_DM_LS/H2O-dft-ls.NREP2.inp -o /tmp/H2O-DFT-LS-NREP2-8GPU.txt<br />
<br />
</pre><br />
<br />
=== Ejemplo contenedor Tensorflow ===<br />
<pre><br />
#!/bin/bash<br />
#---------------Script SBATCH - NLHPC ----------------<br />
#SBATCH -J tensorflow_amd<br />
#SBATCH -p mi210<br />
#SBATCH -n 1<br />
#SBATCH --gres=gpu:1<br />
#SBATCH -c 4<br />
#SBATCH --mem-per-cpu=30354<br />
#SBATCH --mail-user=test@correo.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o tensorflow_amd_%j.out<br />
#SBATCH -e tensorflow_amd%j.err<br />
<br />
#-----------------Toolchain---------------------------<br />
# ----------------Modulos----------------------------<br />
ml aocc/4.2.0<br />
ml apptainer/1.3.1<br />
# ----------------Comando--------------------------<br />
<br />
apptainer exec $IMAGES/tensorflow_latest.sif python script.py<br />
<br />
</pre><br />
<br />
=== Ejemplo contenedor PyTorch ===<br />
<pre><br />
#!/bin/bash<br />
#---------------Script SBATCH - NLHPC ----------------<br />
#SBATCH -J pytorch_amd<br />
#SBATCH -p mi210<br />
#SBATCH -n 1<br />
#SBATCH --gres=gpu:1<br />
#SBATCH -c 4<br />
#SBATCH --mem-per-cpu=30354<br />
#SBATCH --mail-user=test@correo.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o pytorch_amd_%j.out<br />
#SBATCH -e pytorch_amd%j.err<br />
<br />
#-----------------Toolchain---------------------------<br />
# ----------------Modulos----------------------------<br />
ml aocc/4.2.0<br />
ml apptainer/1.3.1<br />
# ----------------Comando--------------------------<br />
<br />
apptainer exec $IMAGES/pytorch_latest.sif python script.py<br />
<br />
</pre><br />
<br />
<br />
Más información pueden encontrar en https://github.com/amd/InfinityHub-CI/<br />
<br />
</pre></div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Apptainer&diff=800Apptainer2024-05-28T14:17:04Z<p>Eguerra: </p>
<hr />
<div>== ¿Qué es? ==<br />
Apptainer es un programa informático gratuito , multiplataforma y de código abierto que realiza la virtualización a nivel del sistema operativo, también conocida como containers.<br />
<br />
Uno de los principales usos de Apptainer es llevar contenedores y reproducibilidad a la informática científica y al mundo de la informática de alto rendimiento (HPC).<br />
<br />
Los contenedores de Apptainer se pueden usar para empaquetar flujos de trabajo científicos completos, software y bibliotecas, e incluso datos. Esto significa que no tiene que pedirle al administrador del clúster que instale nada por usted; puede ponerlo en un contenedor de Apptainer y ejecutarlo.<br />
<br />
El software Apptainer puede importar sus imágenes de Docker sin tener Docker instalado o ser un superusuario.<br />
<br />
¿Necesitas compartir tu código? Póngalo en un contenedor de Apptainer y su colaborador no tendrá que pasar por la molestia de instalar dependencias faltantes. ¿Necesita ejecutar un sistema operativo completamente diferente? Puede "cambiar" el sistema operativo de su host por otro diferente dentro de un contenedor de Apptainer<br />
<br />
== Modulos ==<br />
Para el uso de '''Apptainer''' debe cargar los módulos:<br />
<br />
* ml aocc/4.2.0<br />
* ml apptainer/1.3.1<br />
<br />
== Ejemplos de Lanzador ==<br />
=== Importar imagen de Apptainer ===<br />
Para este ejemplo utilizaremos la imagen de Apptainer hello-world (shub://singularityhub/hello-world), crearemos un directorio llamado Ejemplo y nos posicionaremos en el directorio creado:<br />
<pre><br />
prueba@leftraru1:~$ mkdir Ejemplo<br />
prueba@leftraru1:~$ cd Ejemplo/<br />
</pre><br />
<br />
Cargar módulo de Apptainer:<br />
<pre><br />
prueba@leftraru1:~$ ml purge<br />
prueba@leftraru1:~$ ml aocc/4.2.0<br />
prueba@leftraru1:~$ ml apptainer/1.3.1<br />
</pre><br />
<br />
Crear carpeta temporal:<br />
<pre><br />
prueba@leftraru1:~$ mkdir -p /tmp/singularityce/singularity/mnt/session<br />
</pre><br />
<br />
Importar imagen de Apptainer:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ apptainer pull shub://singularityhub/hello-world<br />
INFO: Downloading shub image<br />
59.75 MiB / 59.75 MiB [=====================================================================================================================================================] 100.00% 12.41 MiB/s 4s<br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 57344<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 10:46 hello-world_latest.sif<br />
</pre><br />
<br />
Ejecutando imagen:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ apptainer run hello-world_latest.sif<br />
INFO: Convert SIF file to sandbox...<br />
Tacotacotaco<br />
INFO: Cleaning up image...<br />
</pre><br />
<br />
Como se puede observar el resultado de ejecutar el contenedor es la palabra: '''Tacotacotaco'''<br />
<br />
=== Generando Script ===<br />
Ejemplo de script para lanzar en la partición general.<br />
<br />
Utilizamos 1 nodos, 44 simulaciones por nodo y utilizamos los 187 Gb de Ram declarados en el script:<br />
<br />
<pre>prueba@leftraru1:~/Ejemplo$ vim script_44cores.sh</pre><br />
<br />
Ejemplo de Script Slurm:<br />
<pre><br />
#!/bin/bash<br />
# ----------------SLURM Parameters----------------<br />
#SBATCH -J Hello-world<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4250<br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o hello-world_%j.out<br />
#SBATCH -e hello-world_%j.err<br />
<br />
#Modulos Necesarios<br />
ml aocc/4.2.0<br />
ml apptainer/1.3.1<br />
<br />
#Creación de carpeta<br />
mkdir -p /tmp/singularityce/singularity/mnt/session<br />
<br />
#Comandos<br />
srun apptainer run hello-world_latest.sif<br />
</pre><br />
<br />
Lanzar script:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ sbatch script_44cores.sh<br />
Submitted batch job 19051335<br />
</pre><br />
<br />
Revisar estado del trabajo:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
19051335 general Hello-wo prueba R 0:12 1 sn045<br />
</pre><br />
<br />
Revisar estado de simulación: (trabajo finalizado correctamente)<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
</pre><br />
<br />
<br />
Revisión de inicio del trabajo mediante correo:<br />
<br />
[[Archivo:Inicio Trabajo 19051335.jpg|no]]<br />
<br />
<br />
<br />
Revisión de finalización de trabajo mediante correo:<br />
<br />
[[Archivo:Finalización Trabajo 19051335.jpg|no]]<br />
<br />
<br />
La tarea fue ejecutada en 3 minutos con 04 segundos.<br />
<br />
Resultados de la tarea (se generan 2 archivos, 1 archivo error y un 1 archivo de salida):<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 61204<br />
-rw-r--r-- 1 prueba nlhpc 3872 Jul 30 11:31 hello-world_19051335.err<br />
-rw-r--r-- 1 prueba nlhpc 572 Jul 30 11:31 hello-world_19051335.out<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 11:16 hello-world_latest.sif<br />
-rwxr-xr-x 1 prueba nlhpc 405 Jul 30 11:30 script_44cores.sh<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.out:<br />
<br />
Aquí podemos ver que la ejecución nos entregó como resultado 44 veces la ejecución del contenedor (la simulación fue ejecutada de forma correcta).<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.out<br />
44 hello-world_19051335.out<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.out<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
...<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.err:<br />
<br />
Aquí podemos ver que Apptainer convirtió la imagen 44 veces y limpio la imagen 44 veces.<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.err<br />
88 hello-world_19051335.err<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.err<br />
Resumen<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Cleaning up image...<br />
INFO: Cleaning up image...<br />
<br />
<br />
</pre><br />
<br />
== Contenedores GPU AMD MI210 ==<br />
Contamos con un directorio especial que contiene una serie de imágenes listas para ser ejecutadas en las GPU AMD MI210. Basta con cargar el módulo de Apptainer:<br />
<br />
<pre> <br />
ml aocc/4.2.0<br />
ml apptainer/1.3.1 <br />
</pre><br />
<br />
<pre><br />
[modules@leftraru1 ~]$ ls $IMAGES<br />
chroma_3.43.0.sif nwchem.sif ryzen-ai-tensorflow2_latest.sif<br />
cp2k_2022.2.amd3.sif openfoam_2206.1.amd3.sif ryzen-ai-tensorflow_latest.sif<br />
grid_0.8.2-20211213.sif openmm_7.7.0_49.sif specfem3d_9c0626d1-20201122.sif<br />
gromacs_2022.3.amd1_174.sif petsc_3.18.amd4.sif specfem3d_globe_1ee10977-20210321.sif<br />
lammps_2022.5.04_130.sif pyfr_1.14.0_48.sif trilinos_1.7.sif<br />
namd_2.15a2-20211101.sif relion_4.0.sif uif-pytorch_uif1.2_rocm5.6.1_vai3.5_py3.8_pytorch1.13.sif<br />
namd3_3.0a9.sif ryzen-ai-pytorch_latest.sif uif-tensorflow_uif1.2_rocm5.6.1_vai3.5_tensorflow2.12.sif<br />
</pre><br />
<br />
=== Ejemplo contenedor CP2K ===<br />
<pre><br />
#!/bin/bash<br />
#---------------Script SBATCH - NLHPC ----------------<br />
#SBATCH -J testamd<br />
#SBATCH -p mi210<br />
#SBATCH -n 16<br />
#SBATCH --gres=gpu:1<br />
#SBATCH -c 4<br />
#SBATCH --mem-per-cpu=30354<br />
#SBATCH --mail-user=test@correo.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o testamd_%j.out<br />
#SBATCH -e testamd_%j.err<br />
<br />
#-----------------Toolchain---------------------------<br />
# ----------------Modulos----------------------------<br />
ml aocc/4.2.0<br />
ml apptainer/1.3.1<br />
# ----------------Comando--------------------------<br />
<br />
apptainer exec $IMAGES/cp2k_2022.2.amd3.sif mpirun -x NUM_CPUS=64 -x NUM_GPUS=6 -x RANK_STRIDE=6 -x OMP_NUM_THREADS=4 --oversubscribe -np 16 --bind-to none set_cpu_affinity.sh set_gpu_affinity.sh cp2k.psmp -i /opt/cp2k/benchmarks/QS_DM_LS/H2O-dft-ls.NREP2.inp -o /tmp/H2O-DFT-LS-NREP2-8GPU.txt<br />
<br />
</pre><br />
<br />
=== Ejemplo contenedor Tensorflow ===<br />
<pre><br />
#!/bin/bash<br />
#---------------Script SBATCH - NLHPC ----------------<br />
#SBATCH -J tensorflow_amd<br />
#SBATCH -p mi210<br />
#SBATCH -n 1<br />
#SBATCH --gres=gpu:1<br />
#SBATCH -c 4<br />
#SBATCH --mem-per-cpu=30354<br />
#SBATCH --mail-user=test@correo.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o tensorflow_amd_%j.out<br />
#SBATCH -e tensorflow_amd%j.err<br />
<br />
#-----------------Toolchain---------------------------<br />
# ----------------Modulos----------------------------<br />
ml aocc/4.2.0<br />
ml apptainer/1.3.1<br />
# ----------------Comando--------------------------<br />
<br />
apptainer exec $IMAGES/tensorflow_latest.sif python script.py<br />
<br />
</pre><br />
<br />
<br />
Más información pueden encontrar en https://github.com/amd/InfinityHub-CI/<br />
<br />
</pre></div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Apptainer&diff=787Apptainer2024-05-14T20:05:51Z<p>Eguerra: </p>
<hr />
<div>== ¿Qué es? ==<br />
Apptainer es un programa informático gratuito , multiplataforma y de código abierto que realiza la virtualización a nivel del sistema operativo, también conocida como containers.<br />
<br />
Uno de los principales usos de Apptainer es llevar contenedores y reproducibilidad a la informática científica y al mundo de la informática de alto rendimiento (HPC).<br />
<br />
Los contenedores de Apptainer se pueden usar para empaquetar flujos de trabajo científicos completos, software y bibliotecas, e incluso datos. Esto significa que no tiene que pedirle al administrador del clúster que instale nada por usted; puede ponerlo en un contenedor de Apptainer y ejecutarlo.<br />
<br />
El software Apptainer puede importar sus imágenes de Docker sin tener Docker instalado o ser un superusuario.<br />
<br />
¿Necesitas compartir tu código? Póngalo en un contenedor de Apptainer y su colaborador no tendrá que pasar por la molestia de instalar dependencias faltantes. ¿Necesita ejecutar un sistema operativo completamente diferente? Puede "cambiar" el sistema operativo de su host por otro diferente dentro de un contenedor de Apptainer<br />
<br />
== Modulos ==<br />
Para el uso de '''Apptainer''' debe cargar los módulos:<br />
<br />
* ml aocc/4.2.0<br />
* ml apptainer/1.3.1<br />
<br />
== Ejemplos de Lanzador ==<br />
=== Importar imagen de Apptainer ===<br />
Para este ejemplo utilizaremos la imagen de Apptainer hello-world (shub://singularityhub/hello-world), crearemos un directorio llamado Ejemplo y nos posicionaremos en el directorio creado:<br />
<pre><br />
prueba@leftraru1:~$ mkdir Ejemplo<br />
prueba@leftraru1:~$ cd Ejemplo/<br />
</pre><br />
<br />
Cargar módulo de Apptainer:<br />
<pre><br />
prueba@leftraru1:~$ ml purge<br />
prueba@leftraru1:~$ ml aocc/4.2.0<br />
prueba@leftraru1:~$ ml apptainer/1.3.1<br />
</pre><br />
<br />
Crear carpeta temporal:<br />
<pre><br />
prueba@leftraru1:~$ mkdir -p /tmp/singularityce/singularity/mnt/session<br />
</pre><br />
<br />
Importar imagen de Apptainer:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ apptainer pull shub://singularityhub/hello-world<br />
INFO: Downloading shub image<br />
59.75 MiB / 59.75 MiB [=====================================================================================================================================================] 100.00% 12.41 MiB/s 4s<br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 57344<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 10:46 hello-world_latest.sif<br />
</pre><br />
<br />
Ejecutando imagen:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ apptainer run hello-world_latest.sif<br />
INFO: Convert SIF file to sandbox...<br />
Tacotacotaco<br />
INFO: Cleaning up image...<br />
</pre><br />
<br />
Como se puede observar el resultado de ejecutar el contenedor es la palabra: '''Tacotacotaco'''<br />
<br />
=== Generando Script ===<br />
Ejemplo de script para lanzar en la partición general.<br />
<br />
Utilizamos 1 nodos, 44 simulaciones por nodo y utilizamos los 187 Gb de Ram declarados en el script:<br />
<br />
<pre>prueba@leftraru1:~/Ejemplo$ vim script_44cores.sh</pre><br />
<br />
Ejemplo de Script Slurm:<br />
<pre><br />
#!/bin/bash<br />
# ----------------SLURM Parameters----------------<br />
#SBATCH -J Hello-world<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4250<br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o hello-world_%j.out<br />
#SBATCH -e hello-world_%j.err<br />
<br />
#Modulos Necesarios<br />
ml aocc/4.2.0<br />
ml apptainer/1.3.1<br />
<br />
#Creación de carpeta<br />
mkdir -p /tmp/singularityce/singularity/mnt/session<br />
<br />
#Comandos<br />
srun apptainer run hello-world_latest.sif<br />
</pre><br />
<br />
Lanzar script:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ sbatch script_44cores.sh<br />
Submitted batch job 19051335<br />
</pre><br />
<br />
Revisar estado del trabajo:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
19051335 general Hello-wo prueba R 0:12 1 sn045<br />
</pre><br />
<br />
Revisar estado de simulación: (trabajo finalizado correctamente)<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
</pre><br />
<br />
<br />
Revisión de inicio del trabajo mediante correo:<br />
<br />
[[Archivo:Inicio Trabajo 19051335.jpg|no]]<br />
<br />
<br />
<br />
Revisión de finalización de trabajo mediante correo:<br />
<br />
[[Archivo:Finalización Trabajo 19051335.jpg|no]]<br />
<br />
<br />
La tarea fue ejecutada en 3 minutos con 04 segundos.<br />
<br />
Resultados de la tarea (se generan 2 archivos, 1 archivo error y un 1 archivo de salida):<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 61204<br />
-rw-r--r-- 1 prueba nlhpc 3872 Jul 30 11:31 hello-world_19051335.err<br />
-rw-r--r-- 1 prueba nlhpc 572 Jul 30 11:31 hello-world_19051335.out<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 11:16 hello-world_latest.sif<br />
-rwxr-xr-x 1 prueba nlhpc 405 Jul 30 11:30 script_44cores.sh<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.out:<br />
<br />
Aquí podemos ver que la ejecución nos entregó como resultado 44 veces la ejecución del contenedor (la simulación fue ejecutada de forma correcta).<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.out<br />
44 hello-world_19051335.out<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.out<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
...<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.err:<br />
<br />
Aquí podemos ver que Apptainer convirtió la imagen 44 veces y limpio la imagen 44 veces.<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.err<br />
88 hello-world_19051335.err<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.err<br />
Resumen<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Cleaning up image...<br />
INFO: Cleaning up image...<br />
<br />
<br />
</pre><br />
<br />
== Contenedores GPU AMD MI210 ==<br />
Contamos con un directorio especial que contiene una serie de imágenes listas para ser ejecutadas en las GPU AMD MI210. Basta con cargar el módulo de Apptainer:<br />
<br />
<pre> <br />
ml aocc/4.2.0<br />
ml apptainer/1.3.1 <br />
</pre><br />
<br />
<pre><br />
[modules@leftraru1 ~]$ ls $IMAGES<br />
chroma_3.43.0.sif nwchem.sif ryzen-ai-tensorflow2_latest.sif<br />
cp2k_2022.2.amd3.sif openfoam_2206.1.amd3.sif ryzen-ai-tensorflow_latest.sif<br />
grid_0.8.2-20211213.sif openmm_7.7.0_49.sif specfem3d_9c0626d1-20201122.sif<br />
gromacs_2022.3.amd1_174.sif petsc_3.18.amd4.sif specfem3d_globe_1ee10977-20210321.sif<br />
lammps_2022.5.04_130.sif pyfr_1.14.0_48.sif trilinos_1.7.sif<br />
namd_2.15a2-20211101.sif relion_4.0.sif uif-pytorch_uif1.2_rocm5.6.1_vai3.5_py3.8_pytorch1.13.sif<br />
namd3_3.0a9.sif ryzen-ai-pytorch_latest.sif uif-tensorflow_uif1.2_rocm5.6.1_vai3.5_tensorflow2.12.sif<br />
</pre><br />
<br />
=== Ejemplo contenedor CP2K ===<br />
<pre><br />
#!/bin/bash<br />
#---------------Script SBATCH - NLHPC ----------------<br />
#SBATCH -J testamd<br />
#SBATCH -p mi210<br />
#SBATCH -n 16<br />
#SBATCH --gres=gpu:1<br />
#SBATCH -c 4<br />
#SBATCH --mem-per-cpu=30354<br />
#SBATCH --mail-user=test@correo.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o testamd_%j.out<br />
#SBATCH -e testamd_%j.err<br />
<br />
#-----------------Toolchain---------------------------<br />
# ----------------Modulos----------------------------<br />
ml aocc/4.2.0<br />
ml apptainer/1.3.1<br />
# ----------------Comando--------------------------<br />
<br />
apptainer exec $IMAGES/cp2k_2022.2.amd3.sif mpirun -x NUM_CPUS=64 -x NUM_GPUS=6 -x RANK_STRIDE=6 -x OMP_NUM_THREADS=4 --oversubscribe -np 16 --bind-to none set_cpu_affinity.sh set_gpu_affinity.sh cp2k.psmp -i /opt/cp2k/benchmarks/QS_DM_LS/H2O-dft-ls.NREP2.inp -o /tmp/H2O-DFT-LS-NREP2-8GPU.txt<br />
<br />
</pre><br />
<br />
Más información pueden encontrar en https://github.com/amd/InfinityHub-CI/<br />
<br />
</pre></div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Apptainer&diff=786Apptainer2024-05-14T19:57:37Z<p>Eguerra: </p>
<hr />
<div>== ¿Qué es? ==<br />
Apptainer es un programa informático gratuito , multiplataforma y de código abierto que realiza la virtualización a nivel del sistema operativo, también conocida como containers.<br />
<br />
Uno de los principales usos de Apptainer es llevar contenedores y reproducibilidad a la informática científica y al mundo de la informática de alto rendimiento (HPC).<br />
<br />
Los contenedores de Apptainer se pueden usar para empaquetar flujos de trabajo científicos completos, software y bibliotecas, e incluso datos. Esto significa que no tiene que pedirle al administrador del clúster que instale nada por usted; puede ponerlo en un contenedor de Apptainer y ejecutarlo.<br />
<br />
El software Apptainer puede importar sus imágenes de Docker sin tener Docker instalado o ser un superusuario.<br />
<br />
¿Necesitas compartir tu código? Póngalo en un contenedor de Apptainer y su colaborador no tendrá que pasar por la molestia de instalar dependencias faltantes. ¿Necesita ejecutar un sistema operativo completamente diferente? Puede "cambiar" el sistema operativo de su host por otro diferente dentro de un contenedor de Apptainer<br />
<br />
== Modulos ==<br />
Para el uso de '''Apptainer''' debe cargar los módulos:<br />
<br />
* ml aocc/4.2.0<br />
* ml apptainer/1.1.9<br />
<br />
== Ejemplos de Lanzador ==<br />
=== Importar imagen de Apptainer ===<br />
Para este ejemplo utilizaremos la imagen de Apptainer hello-world (shub://singularityhub/hello-world), crearemos un directorio llamado Ejemplo y nos posicionaremos en el directorio creado:<br />
<pre><br />
prueba@leftraru1:~$ mkdir Ejemplo<br />
prueba@leftraru1:~$ cd Ejemplo/<br />
</pre><br />
<br />
Cargar módulo de Apptainer:<br />
<pre><br />
prueba@leftraru1:~$ ml purge<br />
prueba@leftraru1:~$ ml aocc/4.2.0<br />
prueba@leftraru1:~$ ml apptainer/1.1.9<br />
</pre><br />
<br />
Crear carpeta temporal:<br />
<pre><br />
prueba@leftraru1:~$ mkdir -p /tmp/singularityce/singularity/mnt/session<br />
</pre><br />
<br />
Importar imagen de Apptainer:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ apptainer pull shub://singularityhub/hello-world<br />
INFO: Downloading shub image<br />
59.75 MiB / 59.75 MiB [=====================================================================================================================================================] 100.00% 12.41 MiB/s 4s<br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 57344<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 10:46 hello-world_latest.sif<br />
</pre><br />
<br />
Ejecutando imagen:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ apptainer run hello-world_latest.sif<br />
INFO: Convert SIF file to sandbox...<br />
Tacotacotaco<br />
INFO: Cleaning up image...<br />
</pre><br />
<br />
Como se puede observar el resultado de ejecutar el contenedor es la palabra: '''Tacotacotaco'''<br />
<br />
=== Generando Script ===<br />
Ejemplo de script para lanzar en la partición general.<br />
<br />
Utilizamos 1 nodos, 44 simulaciones por nodo y utilizamos los 187 Gb de Ram declarados en el script:<br />
<br />
<pre>prueba@leftraru1:~/Ejemplo$ vim script_44cores.sh</pre><br />
<br />
Ejemplo de Script Slurm:<br />
<pre><br />
#!/bin/bash<br />
# ----------------SLURM Parameters----------------<br />
#SBATCH -J Hello-world<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4250<br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o hello-world_%j.out<br />
#SBATCH -e hello-world_%j.err<br />
<br />
#Modulos Necesarios<br />
ml aocc/4.2.0<br />
ml apptainer/1.1.9<br />
<br />
#Creación de carpeta<br />
mkdir -p /tmp/singularityce/singularity/mnt/session<br />
<br />
#Comandos<br />
srun apptainer run hello-world_latest.sif<br />
</pre><br />
<br />
Lanzar script:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ sbatch script_44cores.sh<br />
Submitted batch job 19051335<br />
</pre><br />
<br />
Revisar estado del trabajo:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
19051335 general Hello-wo prueba R 0:12 1 sn045<br />
</pre><br />
<br />
Revisar estado de simulación: (trabajo finalizado correctamente)<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
</pre><br />
<br />
<br />
Revisión de inicio del trabajo mediante correo:<br />
<br />
[[Archivo:Inicio Trabajo 19051335.jpg|no]]<br />
<br />
<br />
<br />
Revisión de finalización de trabajo mediante correo:<br />
<br />
[[Archivo:Finalización Trabajo 19051335.jpg|no]]<br />
<br />
<br />
La tarea fue ejecutada en 3 minutos con 04 segundos.<br />
<br />
Resultados de la tarea (se generan 2 archivos, 1 archivo error y un 1 archivo de salida):<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 61204<br />
-rw-r--r-- 1 prueba nlhpc 3872 Jul 30 11:31 hello-world_19051335.err<br />
-rw-r--r-- 1 prueba nlhpc 572 Jul 30 11:31 hello-world_19051335.out<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 11:16 hello-world_latest.sif<br />
-rwxr-xr-x 1 prueba nlhpc 405 Jul 30 11:30 script_44cores.sh<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.out:<br />
<br />
Aquí podemos ver que la ejecución nos entregó como resultado 44 veces la ejecución del contenedor (la simulación fue ejecutada de forma correcta).<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.out<br />
44 hello-world_19051335.out<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.out<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
...<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.err:<br />
<br />
Aquí podemos ver que Apptainer convirtió la imagen 44 veces y limpio la imagen 44 veces.<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.err<br />
88 hello-world_19051335.err<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.err<br />
Resumen<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Cleaning up image...<br />
INFO: Cleaning up image...<br />
<br />
<br />
</pre><br />
<br />
== Contenedores GPU AMD MI210 ==<br />
Contamos con un directorio especial que contiene una serie de imágenes listas para ser ejecutadas en las GPU AMD MI210. Basta con cargar el módulo de Apptainer:<br />
<br />
<pre> <br />
ml aocc/4.2.0<br />
ml apptainer/1.1.9 <br />
</pre><br />
<br />
<pre><br />
[modules@leftraru1 ~]$ ls $IMAGES<br />
chroma_3.43.0.sif nwchem.sif ryzen-ai-tensorflow2_latest.sif<br />
cp2k_2022.2.amd3.sif openfoam_2206.1.amd3.sif ryzen-ai-tensorflow_latest.sif<br />
grid_0.8.2-20211213.sif openmm_7.7.0_49.sif specfem3d_9c0626d1-20201122.sif<br />
gromacs_2022.3.amd1_174.sif petsc_3.18.amd4.sif specfem3d_globe_1ee10977-20210321.sif<br />
lammps_2022.5.04_130.sif pyfr_1.14.0_48.sif trilinos_1.7.sif<br />
namd_2.15a2-20211101.sif relion_4.0.sif uif-pytorch_uif1.2_rocm5.6.1_vai3.5_py3.8_pytorch1.13.sif<br />
namd3_3.0a9.sif ryzen-ai-pytorch_latest.sif uif-tensorflow_uif1.2_rocm5.6.1_vai3.5_tensorflow2.12.sif<br />
</pre><br />
<br />
=== Ejemplo contenedor CP2K ===<br />
<pre><br />
#!/bin/bash<br />
#---------------Script SBATCH - NLHPC ----------------<br />
#SBATCH -J testamd<br />
#SBATCH -p mi210<br />
#SBATCH -n 16<br />
#SBATCH --gres=gpu:1<br />
#SBATCH -c 4<br />
#SBATCH --mem-per-cpu=30354<br />
#SBATCH --mail-user=test@correo.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o testamd_%j.out<br />
#SBATCH -e testamd_%j.err<br />
<br />
#-----------------Toolchain---------------------------<br />
# ----------------Modulos----------------------------<br />
ml aocc/4.2.0<br />
ml apptainer/1.1.9<br />
# ----------------Comando--------------------------<br />
<br />
apptainer exec $IMAGES/cp2k_2022.2.amd3.sif mpirun -x NUM_CPUS=64 -x NUM_GPUS=6 -x RANK_STRIDE=6 -x OMP_NUM_THREADS=4 --oversubscribe -np 16 --bind-to none set_cpu_affinity.sh set_gpu_affinity.sh cp2k.psmp -i /opt/cp2k/benchmarks/QS_DM_LS/H2O-dft-ls.NREP2.inp -o /tmp/H2O-DFT-LS-NREP2-8GPU.txt<br />
<br />
</pre><br />
<br />
Más información pueden encontrar en https://github.com/amd/InfinityHub-CI/<br />
<br />
</pre></div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Apptainer&diff=785Apptainer2024-05-14T19:56:38Z<p>Eguerra: </p>
<hr />
<div>== ¿Qué es? ==<br />
Apptainer es un programa informático gratuito , multiplataforma y de código abierto que realiza la virtualización a nivel del sistema operativo, también conocida como containers.<br />
<br />
Uno de los principales usos de Apptainer es llevar contenedores y reproducibilidad a la informática científica y al mundo de la informática de alto rendimiento (HPC).<br />
<br />
Los contenedores de Apptainer se pueden usar para empaquetar flujos de trabajo científicos completos, software y bibliotecas, e incluso datos. Esto significa que no tiene que pedirle al administrador del clúster que instale nada por usted; puede ponerlo en un contenedor de Singularity y ejecutarlo.<br />
<br />
El software Apptainer puede importar sus imágenes de Docker sin tener Docker instalado o ser un superusuario.<br />
<br />
¿Necesitas compartir tu código? Póngalo en un contenedor de Apptainer y su colaborador no tendrá que pasar por la molestia de instalar dependencias faltantes. ¿Necesita ejecutar un sistema operativo completamente diferente? Puede "cambiar" el sistema operativo de su host por otro diferente dentro de un contenedor de Singularity<br />
<br />
== Modulos ==<br />
Para el uso de '''Apptainer''' debe cargar los módulos:<br />
<br />
* ml aocc/4.2.0<br />
* ml apptainer/1.1.9<br />
<br />
== Ejemplos de Lanzador ==<br />
=== Importar imagen de Apptainer ===<br />
Para este ejemplo utilizaremos la imagen de Apptainer hello-world (shub://singularityhub/hello-world), crearemos un directorio llamado Ejemplo y nos posicionaremos en el directorio creado:<br />
<pre><br />
prueba@leftraru1:~$ mkdir Ejemplo<br />
prueba@leftraru1:~$ cd Ejemplo/<br />
</pre><br />
<br />
Cargar módulo de Apptainer:<br />
<pre><br />
prueba@leftraru1:~$ ml purge<br />
prueba@leftraru1:~$ ml aocc/4.2.0<br />
prueba@leftraru1:~$ ml apptainer/1.1.9<br />
</pre><br />
<br />
Crear carpeta temporal:<br />
<pre><br />
prueba@leftraru1:~$ mkdir -p /tmp/singularityce/singularity/mnt/session<br />
</pre><br />
<br />
Importar imagen de Apptainer:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ apptainer pull shub://singularityhub/hello-world<br />
INFO: Downloading shub image<br />
59.75 MiB / 59.75 MiB [=====================================================================================================================================================] 100.00% 12.41 MiB/s 4s<br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 57344<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 10:46 hello-world_latest.sif<br />
</pre><br />
<br />
Ejecutando imagen:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ apptainer run hello-world_latest.sif<br />
INFO: Convert SIF file to sandbox...<br />
Tacotacotaco<br />
INFO: Cleaning up image...<br />
</pre><br />
<br />
Como se puede observar el resultado de ejecutar el contenedor es la palabra: '''Tacotacotaco'''<br />
<br />
=== Generando Script ===<br />
Ejemplo de script para lanzar en la partición general.<br />
<br />
Utilizamos 1 nodos, 44 simulaciones por nodo y utilizamos los 187 Gb de Ram declarados en el script:<br />
<br />
<pre>prueba@leftraru1:~/Ejemplo$ vim script_44cores.sh</pre><br />
<br />
Ejemplo de Script Slurm:<br />
<pre><br />
#!/bin/bash<br />
# ----------------SLURM Parameters----------------<br />
#SBATCH -J Hello-world<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4250<br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o hello-world_%j.out<br />
#SBATCH -e hello-world_%j.err<br />
<br />
#Modulos Necesarios<br />
ml aocc/4.2.0<br />
ml apptainer/1.1.9<br />
<br />
#Creación de carpeta<br />
mkdir -p /tmp/singularityce/singularity/mnt/session<br />
<br />
#Comandos<br />
srun singularity run hello-world_latest.sif<br />
</pre><br />
<br />
Lanzar script:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ sbatch script_44cores.sh<br />
Submitted batch job 19051335<br />
</pre><br />
<br />
Revisar estado del trabajo:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
19051335 general Hello-wo prueba R 0:12 1 sn045<br />
</pre><br />
<br />
Revisar estado de simulación: (trabajo finalizado correctamente)<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
</pre><br />
<br />
<br />
Revisión de inicio del trabajo mediante correo:<br />
<br />
[[Archivo:Inicio Trabajo 19051335.jpg|no]]<br />
<br />
<br />
<br />
Revisión de finalización de trabajo mediante correo:<br />
<br />
[[Archivo:Finalización Trabajo 19051335.jpg|no]]<br />
<br />
<br />
La tarea fue ejecutada en 3 minutos con 04 segundos.<br />
<br />
Resultados de la tarea (se generan 2 archivos, 1 archivo error y un 1 archivo de salida):<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 61204<br />
-rw-r--r-- 1 prueba nlhpc 3872 Jul 30 11:31 hello-world_19051335.err<br />
-rw-r--r-- 1 prueba nlhpc 572 Jul 30 11:31 hello-world_19051335.out<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 11:16 hello-world_latest.sif<br />
-rwxr-xr-x 1 prueba nlhpc 405 Jul 30 11:30 script_44cores.sh<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.out:<br />
<br />
Aquí podemos ver que la ejecución nos entregó como resultado 44 veces la ejecución del contenedor (la simulación fue ejecutada de forma correcta).<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.out<br />
44 hello-world_19051335.out<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.out<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
...<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.err:<br />
<br />
Aquí podemos ver que Apptainer convirtió la imagen 44 veces y limpio la imagen 44 veces.<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.err<br />
88 hello-world_19051335.err<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.err<br />
Resumen<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Cleaning up image...<br />
INFO: Cleaning up image...<br />
<br />
<br />
</pre><br />
<br />
== Contenedores GPU AMD MI210 ==<br />
Contamos con un directorio especial que contiene una serie de imágenes listas para ser ejecutadas en las GPU AMD MI210. Basta con cargar el módulo de Apptainer:<br />
<br />
<pre> <br />
ml aocc/4.2.0<br />
ml apptainer/1.1.9 <br />
</pre><br />
<br />
<pre><br />
[modules@leftraru1 ~]$ ls $IMAGES<br />
chroma_3.43.0.sif nwchem.sif ryzen-ai-tensorflow2_latest.sif<br />
cp2k_2022.2.amd3.sif openfoam_2206.1.amd3.sif ryzen-ai-tensorflow_latest.sif<br />
grid_0.8.2-20211213.sif openmm_7.7.0_49.sif specfem3d_9c0626d1-20201122.sif<br />
gromacs_2022.3.amd1_174.sif petsc_3.18.amd4.sif specfem3d_globe_1ee10977-20210321.sif<br />
lammps_2022.5.04_130.sif pyfr_1.14.0_48.sif trilinos_1.7.sif<br />
namd_2.15a2-20211101.sif relion_4.0.sif uif-pytorch_uif1.2_rocm5.6.1_vai3.5_py3.8_pytorch1.13.sif<br />
namd3_3.0a9.sif ryzen-ai-pytorch_latest.sif uif-tensorflow_uif1.2_rocm5.6.1_vai3.5_tensorflow2.12.sif<br />
</pre><br />
<br />
=== Ejemplo contenedor CP2K ===<br />
<pre><br />
#!/bin/bash<br />
#---------------Script SBATCH - NLHPC ----------------<br />
#SBATCH -J testamd<br />
#SBATCH -p mi210<br />
#SBATCH -n 16<br />
#SBATCH --gres=gpu:1<br />
#SBATCH -c 4<br />
#SBATCH --mem-per-cpu=30354<br />
#SBATCH --mail-user=test@correo.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o testamd_%j.out<br />
#SBATCH -e testamd_%j.err<br />
<br />
#-----------------Toolchain---------------------------<br />
# ----------------Modulos----------------------------<br />
ml aocc/4.2.0<br />
ml apptainer/1.1.9<br />
# ----------------Comando--------------------------<br />
<br />
apptainer exec $IMAGES/cp2k_2022.2.amd3.sif mpirun -x NUM_CPUS=64 -x NUM_GPUS=6 -x RANK_STRIDE=6 -x OMP_NUM_THREADS=4 --oversubscribe -np 16 --bind-to none set_cpu_affinity.sh set_gpu_affinity.sh cp2k.psmp -i /opt/cp2k/benchmarks/QS_DM_LS/H2O-dft-ls.NREP2.inp -o /tmp/H2O-DFT-LS-NREP2-8GPU.txt<br />
<br />
</pre><br />
<br />
Más información pueden encontrar en https://github.com/amd/InfinityHub-CI/<br />
<br />
</pre></div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Apptainer&diff=784Apptainer2024-05-14T19:00:23Z<p>Eguerra: Página creada con «== ¿Qué es? == Apptainer es un programa informático gratuito , multiplataforma y de código abierto que realiza la virtualización a nivel del sistema operativo, también conocida como containers. Uno de los principales usos de Singularity es llevar contenedores y reproducibilidad a la informática científica y al mundo de la informática de alto rendimiento (HPC). Los contenedores de Apptainer se pueden usar para empaquetar flujos de trabajo científicos comple…»</p>
<hr />
<div>== ¿Qué es? ==<br />
Apptainer es un programa informático gratuito , multiplataforma y de código abierto que realiza la virtualización a nivel del sistema operativo, también conocida como containers.<br />
<br />
Uno de los principales usos de Singularity es llevar contenedores y reproducibilidad a la informática científica y al mundo de la informática de alto rendimiento (HPC).<br />
<br />
Los contenedores de Apptainer se pueden usar para empaquetar flujos de trabajo científicos completos, software y bibliotecas, e incluso datos. Esto significa que no tiene que pedirle al administrador del clúster que instale nada por usted; puede ponerlo en un contenedor de Singularity y ejecutarlo.<br />
<br />
El software Apptainer puede importar sus imágenes de Docker sin tener Docker instalado o ser un superusuario.<br />
<br />
¿Necesitas compartir tu código? Póngalo en un contenedor de Apptainer y su colaborador no tendrá que pasar por la molestia de instalar dependencias faltantes. ¿Necesita ejecutar un sistema operativo completamente diferente? Puede "cambiar" el sistema operativo de su host por otro diferente dentro de un contenedor de Singularity<br />
<br />
== Modulos ==<br />
Para el uso de '''Apptainer''' debe cargar los módulos:<br />
<br />
* ml aocc/4.2.0<br />
* ml apptainer/1.1.9<br />
<br />
== Ejemplos de Lanzador ==<br />
=== Importar imagen de Apptainer ===<br />
Para este ejemplo utilizaremos la imagen de Apptainer hello-world (shub://singularityhub/hello-world), crearemos un directorio llamado Ejemplo y nos posicionaremos en el directorio creado:<br />
<pre><br />
prueba@leftraru1:~$ mkdir Ejemplo<br />
prueba@leftraru1:~$ cd Ejemplo/<br />
</pre><br />
<br />
Cargar módulo de Apptainer:<br />
<pre><br />
prueba@leftraru1:~$ ml purge<br />
prueba@leftraru1:~$ ml aocc/4.2.0<br />
prueba@leftraru1:~$ ml apptainer/1.1.9<br />
</pre><br />
<br />
Crear carpeta temporal:<br />
<pre><br />
prueba@leftraru1:~$ mkdir -p /tmp/singularityce/singularity/mnt/session<br />
</pre><br />
<br />
Importar imagen de Apptainer:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ apptainer pull shub://singularityhub/hello-world<br />
INFO: Downloading shub image<br />
59.75 MiB / 59.75 MiB [=====================================================================================================================================================] 100.00% 12.41 MiB/s 4s<br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 57344<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 10:46 hello-world_latest.sif<br />
</pre><br />
<br />
Ejecutando imagen:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ apptainer run hello-world_latest.sif<br />
INFO: Convert SIF file to sandbox...<br />
Tacotacotaco<br />
INFO: Cleaning up image...<br />
</pre><br />
<br />
Como se puede observar el resultado de ejecutar el contenedor es la palabra: '''Tacotacotaco'''<br />
<br />
=== Generando Script ===<br />
Ejemplo de script para lanzar en la partición general.<br />
<br />
Utilizamos 1 nodos, 44 simulaciones por nodo y utilizamos los 187 Gb de Ram declarados en el script:<br />
<br />
<pre>prueba@leftraru1:~/Ejemplo$ vim script_44cores.sh</pre><br />
<br />
Ejemplo de Script Slurm:<br />
<pre><br />
#!/bin/bash<br />
# ----------------SLURM Parameters----------------<br />
#SBATCH -J Hello-world<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4250<br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o hello-world_%j.out<br />
#SBATCH -e hello-world_%j.err<br />
<br />
#Modulos Necesarios<br />
ml aocc/4.2.0<br />
ml apptainer/1.1.9<br />
<br />
#Creación de carpeta<br />
mkdir -p /tmp/singularityce/singularity/mnt/session<br />
<br />
#Comandos<br />
srun singularity run hello-world_latest.sif<br />
</pre><br />
<br />
Lanzar script:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ sbatch script_44cores.sh<br />
Submitted batch job 19051335<br />
</pre><br />
<br />
Revisar estado del trabajo:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
19051335 general Hello-wo prueba R 0:12 1 sn045<br />
</pre><br />
<br />
Revisar estado de simulación: (trabajo finalizado correctamente)<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
</pre><br />
<br />
<br />
Revisión de inicio del trabajo mediante correo:<br />
<br />
[[Archivo:Inicio Trabajo 19051335.jpg|no]]<br />
<br />
<br />
<br />
Revisión de finalización de trabajo mediante correo:<br />
<br />
[[Archivo:Finalización Trabajo 19051335.jpg|no]]<br />
<br />
<br />
La tarea fue ejecutada en 3 minutos con 04 segundos.<br />
<br />
Resultados de la tarea (se generan 2 archivos, 1 archivo error y un 1 archivo de salida):<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 61204<br />
-rw-r--r-- 1 prueba nlhpc 3872 Jul 30 11:31 hello-world_19051335.err<br />
-rw-r--r-- 1 prueba nlhpc 572 Jul 30 11:31 hello-world_19051335.out<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 11:16 hello-world_latest.sif<br />
-rwxr-xr-x 1 prueba nlhpc 405 Jul 30 11:30 script_44cores.sh<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.out:<br />
<br />
Aquí podemos ver que la ejecución nos entregó como resultado 44 veces la ejecución del contenedor (la simulación fue ejecutada de forma correcta).<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.out<br />
44 hello-world_19051335.out<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.out<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
...<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.err:<br />
<br />
Aquí podemos ver que Apptainer convirtió la imagen 44 veces y limpio la imagen 44 veces.<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.err<br />
88 hello-world_19051335.err<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.err<br />
Resumen<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Cleaning up image...<br />
INFO: Cleaning up image...<br />
<br />
<br />
</pre><br />
<br />
== Contenedores GPU AMD MI210 ==<br />
Contamos con un directorio especial que contiene una serie de imágenes listas para ser ejecutadas en las GPU AMD MI210. Basta con cargar el módulo de Apptainer:<br />
<br />
<pre> <br />
ml aocc/4.2.0<br />
ml apptainer/1.1.9 <br />
</pre><br />
<br />
<pre><br />
[modules@leftraru1 ~]$ ls $IMAGES<br />
chroma_3.43.0.sif nwchem.sif ryzen-ai-tensorflow2_latest.sif<br />
cp2k_2022.2.amd3.sif openfoam_2206.1.amd3.sif ryzen-ai-tensorflow_latest.sif<br />
grid_0.8.2-20211213.sif openmm_7.7.0_49.sif specfem3d_9c0626d1-20201122.sif<br />
gromacs_2022.3.amd1_174.sif petsc_3.18.amd4.sif specfem3d_globe_1ee10977-20210321.sif<br />
lammps_2022.5.04_130.sif pyfr_1.14.0_48.sif trilinos_1.7.sif<br />
namd_2.15a2-20211101.sif relion_4.0.sif uif-pytorch_uif1.2_rocm5.6.1_vai3.5_py3.8_pytorch1.13.sif<br />
namd3_3.0a9.sif ryzen-ai-pytorch_latest.sif uif-tensorflow_uif1.2_rocm5.6.1_vai3.5_tensorflow2.12.sif<br />
</pre><br />
<br />
=== Ejemplo contenedor CP2K ===<br />
<pre><br />
#!/bin/bash<br />
#---------------Script SBATCH - NLHPC ----------------<br />
#SBATCH -J testamd<br />
#SBATCH -p mi210<br />
#SBATCH -n 16<br />
#SBATCH --gres=gpu:1<br />
#SBATCH -c 4<br />
#SBATCH --mem-per-cpu=30354<br />
#SBATCH --mail-user=test@correo.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o testamd_%j.out<br />
#SBATCH -e testamd_%j.err<br />
<br />
#-----------------Toolchain---------------------------<br />
# ----------------Modulos----------------------------<br />
ml aocc/4.2.0<br />
ml apptainer/1.1.9<br />
# ----------------Comando--------------------------<br />
<br />
apptainer exec $IMAGES/cp2k_2022.2.amd3.sif mpirun -x NUM_CPUS=64 -x NUM_GPUS=6 -x RANK_STRIDE=6 -x OMP_NUM_THREADS=4 --oversubscribe -np 16 --bind-to none set_cpu_affinity.sh set_gpu_affinity.sh cp2k.psmp -i /opt/cp2k/benchmarks/QS_DM_LS/H2O-dft-ls.NREP2.inp -o /tmp/H2O-DFT-LS-NREP2-8GPU.txt<br />
<br />
</pre><br />
<br />
Más información pueden encontrar en https://github.com/amd/InfinityHub-CI/<br />
<br />
</pre></div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Singularity&diff=773Singularity2024-04-30T15:50:03Z<p>Eguerra: </p>
<hr />
<div>== ¿Qué es? ==<br />
Singularity es un programa informático gratuito , multiplataforma y de código abierto que realiza la virtualización a nivel del sistema operativo, también conocida como containers.<br />
<br />
Uno de los principales usos de Singularity es llevar contenedores y reproducibilidad a la informática científica y al mundo de la informática de alto rendimiento (HPC).<br />
<br />
Los contenedores de Singularity se pueden usar para empaquetar flujos de trabajo científicos completos, software y bibliotecas, e incluso datos. Esto significa que no tiene que pedirle al administrador del clúster que instale nada por usted; puede ponerlo en un contenedor de Singularity y ejecutarlo.<br />
<br />
El software Singularity puede importar sus imágenes de Docker sin tener Docker instalado o ser un superusuario.<br />
<br />
¿Necesitas compartir tu código? Póngalo en un contenedor de Singularity y su colaborador no tendrá que pasar por la molestia de instalar dependencias faltantes. ¿Necesita ejecutar un sistema operativo completamente diferente? Puede "cambiar" el sistema operativo de su host por otro diferente dentro de un contenedor de Singularity<br />
<br />
== Modulos ==<br />
Para el uso de '''Singularity''' debe cargar los módulos:<br />
<br />
* ml purge<br />
* ml intel/2022.00<br />
* ml singularityCE<br />
<br />
== Ejemplos de Lanzador ==<br />
=== Importar imagen de Singularity ===<br />
Para este ejemplo utilizaremos la imagen de Singularity hello-world (shub://singularityhub/hello-world), crearemos un directorio llamado Ejemplo y nos posicionaremos en el directorio creado:<br />
<pre><br />
prueba@leftraru1:~$ mkdir Ejemplo<br />
prueba@leftraru1:~$ cd Ejemplo/<br />
</pre><br />
<br />
Cargar módulo de Singularity:<br />
<pre><br />
prueba@leftraru1:~$ ml purge<br />
prueba@leftraru1:~$ ml intel/2022.00<br />
prueba@leftraru1:~$ ml singularityCE<br />
</pre><br />
<br />
Crear carpeta temporal:<br />
<pre><br />
prueba@leftraru1:~$ mkdir -p /tmp/singularityce/singularity/mnt/session<br />
</pre><br />
<br />
Importar imagen de Singularity:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ singularity pull shub://singularityhub/hello-world<br />
INFO: Downloading shub image<br />
59.75 MiB / 59.75 MiB [=====================================================================================================================================================] 100.00% 12.41 MiB/s 4s<br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 57344<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 10:46 hello-world_latest.sif<br />
</pre><br />
<br />
Ejecutando imagen:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ singularity run hello-world_latest.sif<br />
INFO: Convert SIF file to sandbox...<br />
Tacotacotaco<br />
INFO: Cleaning up image...<br />
</pre><br />
<br />
Como se puede observar el resultado de ejecutar el contenedor es la palabra: '''Tacotacotaco'''<br />
<br />
=== Generando Script ===<br />
Ejemplo de script para lanzar en la partición general.<br />
<br />
Utilizamos 1 nodos, 44 simulaciones por nodo y utilizamos los 187 Gb de Ram declarados en el script:<br />
<br />
<pre>prueba@leftraru1:~/Ejemplo$ vim script_44cores.sh</pre><br />
<br />
Ejemplo de Script Slurm:<br />
<pre><br />
#!/bin/bash<br />
# ----------------SLURM Parameters----------------<br />
#SBATCH -J Hello-world<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4250<br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o hello-world_%j.out<br />
#SBATCH -e hello-world_%j.err<br />
<br />
#Modulos Necesarios<br />
ml purge<br />
ml intel/2022.00<br />
ml singularityCE<br />
<br />
#Creación de carpeta<br />
mkdir -p /tmp/singularityce/singularity/mnt/session<br />
<br />
#Comandos<br />
srun singularity run hello-world_latest.sif<br />
</pre><br />
<br />
Lanzar script:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ sbatch script_44cores.sh<br />
Submitted batch job 19051335<br />
</pre><br />
<br />
Revisar estado del trabajo:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
19051335 general Hello-wo prueba R 0:12 1 sn045<br />
</pre><br />
<br />
Revisar estado de simulación: (trabajo finalizado correctamente)<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
</pre><br />
<br />
<br />
Revisión de inicio del trabajo mediante correo:<br />
<br />
[[Archivo:Inicio Trabajo 19051335.jpg|no]]<br />
<br />
<br />
<br />
Revisión de finalización de trabajo mediante correo:<br />
<br />
[[Archivo:Finalización Trabajo 19051335.jpg|no]]<br />
<br />
<br />
La tarea fue ejecutada en 3 minutos con 04 segundos.<br />
<br />
Resultados de la tarea (se generan 2 archivos, 1 archivo error y un 1 archivo de salida):<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 61204<br />
-rw-r--r-- 1 prueba nlhpc 3872 Jul 30 11:31 hello-world_19051335.err<br />
-rw-r--r-- 1 prueba nlhpc 572 Jul 30 11:31 hello-world_19051335.out<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 11:16 hello-world_latest.sif<br />
-rwxr-xr-x 1 prueba nlhpc 405 Jul 30 11:30 script_44cores.sh<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.out:<br />
<br />
Aquí podemos ver que la ejecución nos entregó como resultado 44 veces la ejecución del contenedor (la simulación fue ejecutada de forma correcta).<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.out<br />
44 hello-world_19051335.out<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.out<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
...<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.err:<br />
<br />
Aquí podemos ver que Singularity convirtió la imagen 44 veces y limpio la imagen 44 veces.<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.err<br />
88 hello-world_19051335.err<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.err<br />
Resumen<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Cleaning up image...<br />
INFO: Cleaning up image...<br />
<br />
<br />
</pre><br />
<br />
== Contenedores GPU AMD MI210 ==<br />
Contamos con un directorio especial que contiene una serie de imágenes listas para ser ejecutadas en las GPU AMD MI210. Basta con cargar el módulo de Singularity:<br />
<br />
<pre> <br />
ml singularityCE/3.10.3 <br />
</pre><br />
<br />
<pre><br />
[modules@leftraru1 ~]$ ls $IMAGES<br />
chroma_3.43.0.sif nwchem.sif ryzen-ai-tensorflow2_latest.sif<br />
cp2k_2022.2.amd3.sif openfoam_2206.1.amd3.sif ryzen-ai-tensorflow_latest.sif<br />
grid_0.8.2-20211213.sif openmm_7.7.0_49.sif specfem3d_9c0626d1-20201122.sif<br />
gromacs_2022.3.amd1_174.sif petsc_3.18.amd4.sif specfem3d_globe_1ee10977-20210321.sif<br />
lammps_2022.5.04_130.sif pyfr_1.14.0_48.sif trilinos_1.7.sif<br />
namd_2.15a2-20211101.sif relion_4.0.sif uif-pytorch_uif1.2_rocm5.6.1_vai3.5_py3.8_pytorch1.13.sif<br />
namd3_3.0a9.sif ryzen-ai-pytorch_latest.sif uif-tensorflow_uif1.2_rocm5.6.1_vai3.5_tensorflow2.12.sif<br />
</pre><br />
<br />
=== Ejemplo contenedor CP2K ===<br />
<pre><br />
#!/bin/bash<br />
#---------------Script SBATCH - NLHPC ----------------<br />
#SBATCH -J testamd<br />
#SBATCH -p mi210<br />
#SBATCH -n 16<br />
#SBATCH --gres=gpu:1<br />
#SBATCH -c 4<br />
#SBATCH --mem-per-cpu=30354<br />
#SBATCH --mail-user=test@correo.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o testamd_%j.out<br />
#SBATCH -e testamd_%j.err<br />
<br />
#-----------------Toolchain---------------------------<br />
# ----------------Modulos----------------------------<br />
ml singularityCE/3.10.3<br />
# ----------------Comando--------------------------<br />
<br />
singularity exec $IMAGES/cp2k_2022.2.amd3.sif mpirun -x NUM_CPUS=64 -x NUM_GPUS=6 -x RANK_STRIDE=6 -x OMP_NUM_THREADS=4 --oversubscribe -np 16 --bind-to none set_cpu_affinity.sh set_gpu_affinity.sh cp2k.psmp -i /opt/cp2k/benchmarks/QS_DM_LS/H2O-dft-ls.NREP2.inp -o /tmp/H2O-DFT-LS-NREP2-8GPU.txt<br />
<br />
</pre><br />
<br />
Más información pueden encontrar en https://github.com/amd/InfinityHub-CI/<br />
<br />
</pre></div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Singularity&diff=772Singularity2024-04-30T15:48:58Z<p>Eguerra: </p>
<hr />
<div>== ¿Qué es? ==<br />
Singularity es un programa informático gratuito , multiplataforma y de código abierto que realiza la virtualización a nivel del sistema operativo, también conocida como containers.<br />
<br />
Uno de los principales usos de Singularity es llevar contenedores y reproducibilidad a la informática científica y al mundo de la informática de alto rendimiento (HPC).<br />
<br />
Los contenedores de Singularity se pueden usar para empaquetar flujos de trabajo científicos completos, software y bibliotecas, e incluso datos. Esto significa que no tiene que pedirle al administrador del clúster que instale nada por usted; puede ponerlo en un contenedor de Singularity y ejecutarlo.<br />
<br />
El software Singularity puede importar sus imágenes de Docker sin tener Docker instalado o ser un superusuario.<br />
<br />
¿Necesitas compartir tu código? Póngalo en un contenedor de Singularity y su colaborador no tendrá que pasar por la molestia de instalar dependencias faltantes. ¿Necesita ejecutar un sistema operativo completamente diferente? Puede "cambiar" el sistema operativo de su host por otro diferente dentro de un contenedor de Singularity<br />
<br />
== Modulos ==<br />
Para el uso de '''Singularity''' debe cargar los módulos:<br />
<br />
* ml purge<br />
* ml intel/2022.00<br />
* ml singularityCE<br />
<br />
== Ejemplos de Lanzador ==<br />
=== Importar imagen de Singularity ===<br />
Para este ejemplo utilizaremos la imagen de Singularity hello-world (shub://singularityhub/hello-world), crearemos un directorio llamado Ejemplo y nos posicionaremos en el directorio creado:<br />
<pre><br />
prueba@leftraru1:~$ mkdir Ejemplo<br />
prueba@leftraru1:~$ cd Ejemplo/<br />
</pre><br />
<br />
Cargar módulo de Singularity:<br />
<pre><br />
prueba@leftraru1:~$ ml purge<br />
prueba@leftraru1:~$ ml intel/2022.00<br />
prueba@leftraru1:~$ ml singularityCE<br />
</pre><br />
<br />
Crear carpeta temporal:<br />
<pre><br />
prueba@leftraru1:~$ mkdir -p /tmp/singularityce/singularity/mnt/session<br />
</pre><br />
<br />
Importar imagen de Singularity:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ singularity pull shub://singularityhub/hello-world<br />
INFO: Downloading shub image<br />
59.75 MiB / 59.75 MiB [=====================================================================================================================================================] 100.00% 12.41 MiB/s 4s<br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 57344<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 10:46 hello-world_latest.sif<br />
</pre><br />
<br />
Ejecutando imagen:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ singularity run hello-world_latest.sif<br />
INFO: Convert SIF file to sandbox...<br />
Tacotacotaco<br />
INFO: Cleaning up image...<br />
</pre><br />
<br />
Como se puede observar el resultado de ejecutar el contenedor es la palabra: '''Tacotacotaco'''<br />
<br />
=== Generando Script ===<br />
Ejemplo de script para lanzar en la partición general.<br />
<br />
Utilizamos 1 nodos, 44 simulaciones por nodo y utilizamos los 187 Gb de Ram declarados en el script:<br />
<br />
<pre>prueba@leftraru1:~/Ejemplo$ vim script_44cores.sh</pre><br />
<br />
Ejemplo de Script Slurm:<br />
<pre><br />
#!/bin/bash<br />
# ----------------SLURM Parameters----------------<br />
#SBATCH -J Hello-world<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4250<br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o hello-world_%j.out<br />
#SBATCH -e hello-world_%j.err<br />
<br />
#Modulos Necesarios<br />
ml purge<br />
ml intel/2022.00<br />
ml singularityCE<br />
<br />
#Creación de carpeta<br />
mkdir -p /tmp/singularityce/singularity/mnt/session<br />
<br />
#Comandos<br />
srun singularity run hello-world_latest.sif<br />
</pre><br />
<br />
Lanzar script:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ sbatch script_44cores.sh<br />
Submitted batch job 19051335<br />
</pre><br />
<br />
Revisar estado del trabajo:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
19051335 general Hello-wo prueba R 0:12 1 sn045<br />
</pre><br />
<br />
Revisar estado de simulación: (trabajo finalizado correctamente)<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
</pre><br />
<br />
<br />
Revisión de inicio del trabajo mediante correo:<br />
<br />
[[Archivo:Inicio Trabajo 19051335.jpg|no]]<br />
<br />
<br />
<br />
Revisión de finalización de trabajo mediante correo:<br />
<br />
[[Archivo:Finalización Trabajo 19051335.jpg|no]]<br />
<br />
<br />
La tarea fue ejecutada en 3 minutos con 04 segundos.<br />
<br />
Resultados de la tarea (se generan 2 archivos, 1 archivo error y un 1 archivo de salida):<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 61204<br />
-rw-r--r-- 1 prueba nlhpc 3872 Jul 30 11:31 hello-world_19051335.err<br />
-rw-r--r-- 1 prueba nlhpc 572 Jul 30 11:31 hello-world_19051335.out<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 11:16 hello-world_latest.sif<br />
-rwxr-xr-x 1 prueba nlhpc 405 Jul 30 11:30 script_44cores.sh<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.out:<br />
<br />
Aquí podemos ver que la ejecución nos entregó como resultado 44 veces la ejecución del contenedor (la simulación fue ejecutada de forma correcta).<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.out<br />
44 hello-world_19051335.out<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.out<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
...<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.err:<br />
<br />
Aquí podemos ver que Singularity convirtió la imagen 44 veces y limpio la imagen 44 veces.<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.err<br />
88 hello-world_19051335.err<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.err<br />
Resumen<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Cleaning up image...<br />
INFO: Cleaning up image...<br />
<br />
<br />
</pre><br />
<br />
== Contenedores GPU AMD MI210 ==<br />
Contamos con un directorio especial que contiene una serie de imágenes listas para ser ejecutadas en las GPU AMD MI210. Basta con cargar el módulo de Singularity:<br />
<br />
<pre> <br />
ml singularityCE/3.10.3 <br />
</pre><br />
<br />
<pre><br />
[modules@leftraru1 ~]$ ls $IMAGES<br />
chroma_3.43.0.sif nwchem.sif ryzen-ai-tensorflow2_latest.sif<br />
cp2k_2022.2.amd3.sif openfoam_2206.1.amd3.sif ryzen-ai-tensorflow_latest.sif<br />
grid_0.8.2-20211213.sif openmm_7.7.0_49.sif specfem3d_9c0626d1-20201122.sif<br />
gromacs_2022.3.amd1_174.sif petsc_3.18.amd4.sif specfem3d_globe_1ee10977-20210321.sif<br />
lammps_2022.5.04_130.sif pyfr_1.14.0_48.sif trilinos_1.7.sif<br />
namd_2.15a2-20211101.sif relion_4.0.sif uif-pytorch_uif1.2_rocm5.6.1_vai3.5_py3.8_pytorch1.13.sif<br />
namd3_3.0a9.sif ryzen-ai-pytorch_latest.sif uif-tensorflow_uif1.2_rocm5.6.1_vai3.5_tensorflow2.12.sif<br />
</pre><br />
<br />
=== Ejemplo contenedor CP2K ===<br />
<pre><br />
#!/bin/bash<br />
#---------------Script SBATCH - NLHPC ----------------<br />
#SBATCH -J testamd<br />
#SBATCH -p mi210<br />
#SBATCH -n 1<br />
#SBATCH --gres=gpu:1<br />
#SBATCH -c 1<br />
#SBATCH --mem-per-cpu=30354<br />
#SBATCH --mail-user=test@correo.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o testamd_%j.out<br />
#SBATCH -e testamd_%j.err<br />
<br />
#-----------------Toolchain---------------------------<br />
# ----------------Modulos----------------------------<br />
ml singularityCE/3.10.3<br />
# ----------------Comando--------------------------<br />
<br />
singularity exec $IMAGES/cp2k_2022.2.amd3.sif mpirun -x NUM_CPUS=64 -x NUM_GPUS=6 -x RANK_STRIDE=6 -x OMP_NUM_THREADS=4 --oversubscribe -np 16 --bind-to none set_cpu_affinity.sh set_gpu_affinity.sh cp2k.psmp -i /opt/cp2k/benchmarks/QS_DM_LS/H2O-dft-ls.NREP2.inp -o /tmp/H2O-DFT-LS-NREP2-8GPU.txt<br />
<br />
</pre><br />
<br />
Más información pueden encontrar en https://github.com/amd/InfinityHub-CI/<br />
<br />
</pre></div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Singularity&diff=771Singularity2024-04-30T15:45:35Z<p>Eguerra: </p>
<hr />
<div>== ¿Qué es? ==<br />
Singularity es un programa informático gratuito , multiplataforma y de código abierto que realiza la virtualización a nivel del sistema operativo, también conocida como containers.<br />
<br />
Uno de los principales usos de Singularity es llevar contenedores y reproducibilidad a la informática científica y al mundo de la informática de alto rendimiento (HPC).<br />
<br />
Los contenedores de Singularity se pueden usar para empaquetar flujos de trabajo científicos completos, software y bibliotecas, e incluso datos. Esto significa que no tiene que pedirle al administrador del clúster que instale nada por usted; puede ponerlo en un contenedor de Singularity y ejecutarlo.<br />
<br />
El software Singularity puede importar sus imágenes de Docker sin tener Docker instalado o ser un superusuario.<br />
<br />
¿Necesitas compartir tu código? Póngalo en un contenedor de Singularity y su colaborador no tendrá que pasar por la molestia de instalar dependencias faltantes. ¿Necesita ejecutar un sistema operativo completamente diferente? Puede "cambiar" el sistema operativo de su host por otro diferente dentro de un contenedor de Singularity<br />
<br />
== Modulos ==<br />
Para el uso de '''Singularity''' debe cargar los módulos:<br />
<br />
* ml purge<br />
* ml intel/2022.00<br />
* ml singularityCE<br />
<br />
== Ejemplos de Lanzador ==<br />
=== Importar imagen de Singularity ===<br />
Para este ejemplo utilizaremos la imagen de Singularity hello-world (shub://singularityhub/hello-world), crearemos un directorio llamado Ejemplo y nos posicionaremos en el directorio creado:<br />
<pre><br />
prueba@leftraru1:~$ mkdir Ejemplo<br />
prueba@leftraru1:~$ cd Ejemplo/<br />
</pre><br />
<br />
Cargar módulo de Singularity:<br />
<pre><br />
prueba@leftraru1:~$ ml purge<br />
prueba@leftraru1:~$ ml intel/2022.00<br />
prueba@leftraru1:~$ ml singularityCE<br />
</pre><br />
<br />
Crear carpeta temporal:<br />
<pre><br />
prueba@leftraru1:~$ mkdir -p /tmp/singularityce/singularity/mnt/session<br />
</pre><br />
<br />
Importar imagen de Singularity:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ singularity pull shub://singularityhub/hello-world<br />
INFO: Downloading shub image<br />
59.75 MiB / 59.75 MiB [=====================================================================================================================================================] 100.00% 12.41 MiB/s 4s<br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 57344<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 10:46 hello-world_latest.sif<br />
</pre><br />
<br />
Ejecutando imagen:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ singularity run hello-world_latest.sif<br />
INFO: Convert SIF file to sandbox...<br />
Tacotacotaco<br />
INFO: Cleaning up image...<br />
</pre><br />
<br />
Como se puede observar el resultado de ejecutar el contenedor es la palabra: '''Tacotacotaco'''<br />
<br />
=== Generando Script ===<br />
Ejemplo de script para lanzar en la partición general.<br />
<br />
Utilizamos 1 nodos, 44 simulaciones por nodo y utilizamos los 187 Gb de Ram declarados en el script:<br />
<br />
<pre>prueba@leftraru1:~/Ejemplo$ vim script_44cores.sh</pre><br />
<br />
Ejemplo de Script Slurm:<br />
<pre><br />
#!/bin/bash<br />
# ----------------SLURM Parameters----------------<br />
#SBATCH -J Hello-world<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4250<br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o hello-world_%j.out<br />
#SBATCH -e hello-world_%j.err<br />
<br />
#Modulos Necesarios<br />
ml purge<br />
ml intel/2022.00<br />
ml singularityCE<br />
<br />
#Creación de carpeta<br />
mkdir -p /tmp/singularityce/singularity/mnt/session<br />
<br />
#Comandos<br />
srun singularity run hello-world_latest.sif<br />
</pre><br />
<br />
Lanzar script:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ sbatch script_44cores.sh<br />
Submitted batch job 19051335<br />
</pre><br />
<br />
Revisar estado del trabajo:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
19051335 general Hello-wo prueba R 0:12 1 sn045<br />
</pre><br />
<br />
Revisar estado de simulación: (trabajo finalizado correctamente)<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
</pre><br />
<br />
<br />
Revisión de inicio del trabajo mediante correo:<br />
<br />
[[Archivo:Inicio Trabajo 19051335.jpg|no]]<br />
<br />
<br />
<br />
Revisión de finalización de trabajo mediante correo:<br />
<br />
[[Archivo:Finalización Trabajo 19051335.jpg|no]]<br />
<br />
<br />
La tarea fue ejecutada en 3 minutos con 04 segundos.<br />
<br />
Resultados de la tarea (se generan 2 archivos, 1 archivo error y un 1 archivo de salida):<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 61204<br />
-rw-r--r-- 1 prueba nlhpc 3872 Jul 30 11:31 hello-world_19051335.err<br />
-rw-r--r-- 1 prueba nlhpc 572 Jul 30 11:31 hello-world_19051335.out<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 11:16 hello-world_latest.sif<br />
-rwxr-xr-x 1 prueba nlhpc 405 Jul 30 11:30 script_44cores.sh<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.out:<br />
<br />
Aquí podemos ver que la ejecución nos entregó como resultado 44 veces la ejecución del contenedor (la simulación fue ejecutada de forma correcta).<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.out<br />
44 hello-world_19051335.out<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.out<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
...<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.err:<br />
<br />
Aquí podemos ver que Singularity convirtió la imagen 44 veces y limpio la imagen 44 veces.<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.err<br />
88 hello-world_19051335.err<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.err<br />
Resumen<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Cleaning up image...<br />
INFO: Cleaning up image...<br />
<br />
<br />
</pre><br />
<br />
== Contenedores GPU AMD MI210 ==<br />
Contamos con un directorio especial que contiene una serie de imágenes listas para ser ejecutadas en las GPU AMD MI210. Basta con cargar el módulo de Singularity:<br />
<br />
<pre> <br />
ml singularityCE/3.10.3 <br />
</pre><br />
<br />
<pre><br />
[modules@leftraru1 ~]$ ls $IMAGES<br />
chroma_3.43.0.sif nwchem.sif ryzen-ai-tensorflow2_latest.sif<br />
cp2k_2022.2.amd3.sif openfoam_2206.1.amd3.sif ryzen-ai-tensorflow_latest.sif<br />
grid_0.8.2-20211213.sif openmm_7.7.0_49.sif specfem3d_9c0626d1-20201122.sif<br />
gromacs_2022.3.amd1_174.sif petsc_3.18.amd4.sif specfem3d_globe_1ee10977-20210321.sif<br />
lammps_2022.5.04_130.sif pyfr_1.14.0_48.sif trilinos_1.7.sif<br />
namd_2.15a2-20211101.sif relion_4.0.sif uif-pytorch_uif1.2_rocm5.6.1_vai3.5_py3.8_pytorch1.13.sif<br />
namd3_3.0a9.sif ryzen-ai-pytorch_latest.sif uif-tensorflow_uif1.2_rocm5.6.1_vai3.5_tensorflow2.12.sif<br />
</pre><br />
<br />
=== Ejemplo contenedor CP2K ===<br />
<pre><br />
#!/bin/bash<br />
#---------------Script SBATCH - NLHPC ----------------<br />
#SBATCH -J testamd<br />
#SBATCH -p mi210<br />
#SBATCH -n 1<br />
#SBATCH --gres=gpu:1<br />
#SBATCH -c 1<br />
#SBATCH --mem-per-cpu=30354<br />
#SBATCH --mail-user=test@correo.com<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o testamd_%j.out<br />
#SBATCH -e testamd_%j.err<br />
<br />
#-----------------Toolchain---------------------------<br />
# ----------------Modulos----------------------------<br />
ml singularityCE/3.10.3<br />
# ----------------Comando--------------------------<br />
<br />
singularity exec $IMAGES/cp2k_2022.2.amd3.sif mpirun -x NUM_CPUS=64 -x NUM_GPUS=6 -x RANK_STRIDE=6 -x OMP_NUM_THREADS=4 --oversubscribe -np 16 --bind-to none set_cpu_affinity.sh set_gpu_affinity.sh cp2k.psmp -i /opt/cp2k/benchmarks/QS_DM_LS/H2O-dft-ls.NREP2.inp -o /tmp/H2O-DFT-LS-NREP2-8GPU.txt<br />
<br />
</pre><br />
<br />
</pre></div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Singularity&diff=770Singularity2024-04-30T15:09:21Z<p>Eguerra: </p>
<hr />
<div>== ¿Qué es? ==<br />
Singularity es un programa informático gratuito , multiplataforma y de código abierto que realiza la virtualización a nivel del sistema operativo, también conocida como containers.<br />
<br />
Uno de los principales usos de Singularity es llevar contenedores y reproducibilidad a la informática científica y al mundo de la informática de alto rendimiento (HPC).<br />
<br />
Los contenedores de Singularity se pueden usar para empaquetar flujos de trabajo científicos completos, software y bibliotecas, e incluso datos. Esto significa que no tiene que pedirle al administrador del clúster que instale nada por usted; puede ponerlo en un contenedor de Singularity y ejecutarlo.<br />
<br />
El software Singularity puede importar sus imágenes de Docker sin tener Docker instalado o ser un superusuario.<br />
<br />
¿Necesitas compartir tu código? Póngalo en un contenedor de Singularity y su colaborador no tendrá que pasar por la molestia de instalar dependencias faltantes. ¿Necesita ejecutar un sistema operativo completamente diferente? Puede "cambiar" el sistema operativo de su host por otro diferente dentro de un contenedor de Singularity<br />
<br />
== Modulos ==<br />
Para el uso de '''Singularity''' debe cargar los módulos:<br />
<br />
* ml purge<br />
* ml intel/2022.00<br />
* ml singularityCE<br />
<br />
== Ejemplos de Lanzador ==<br />
=== Importar imagen de Singularity ===<br />
Para este ejemplo utilizaremos la imagen de Singularity hello-world (shub://singularityhub/hello-world), crearemos un directorio llamado Ejemplo y nos posicionaremos en el directorio creado:<br />
<pre><br />
prueba@leftraru1:~$ mkdir Ejemplo<br />
prueba@leftraru1:~$ cd Ejemplo/<br />
</pre><br />
<br />
Cargar módulo de Singularity:<br />
<pre><br />
prueba@leftraru1:~$ ml purge<br />
prueba@leftraru1:~$ ml intel/2022.00<br />
prueba@leftraru1:~$ ml singularityCE<br />
</pre><br />
<br />
Crear carpeta temporal:<br />
<pre><br />
prueba@leftraru1:~$ mkdir -p /tmp/singularityce/singularity/mnt/session<br />
</pre><br />
<br />
Importar imagen de Singularity:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ singularity pull shub://singularityhub/hello-world<br />
INFO: Downloading shub image<br />
59.75 MiB / 59.75 MiB [=====================================================================================================================================================] 100.00% 12.41 MiB/s 4s<br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 57344<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 10:46 hello-world_latest.sif<br />
</pre><br />
<br />
Ejecutando imagen:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ singularity run hello-world_latest.sif<br />
INFO: Convert SIF file to sandbox...<br />
Tacotacotaco<br />
INFO: Cleaning up image...<br />
</pre><br />
<br />
Como se puede observar el resultado de ejecutar el contenedor es la palabra: '''Tacotacotaco'''<br />
<br />
=== Generando Script ===<br />
Ejemplo de script para lanzar en la partición general.<br />
<br />
Utilizamos 1 nodos, 44 simulaciones por nodo y utilizamos los 187 Gb de Ram declarados en el script:<br />
<br />
<pre>prueba@leftraru1:~/Ejemplo$ vim script_44cores.sh</pre><br />
<br />
Ejemplo de Script Slurm:<br />
<pre><br />
#!/bin/bash<br />
# ----------------SLURM Parameters----------------<br />
#SBATCH -J Hello-world<br />
#SBATCH -p general<br />
#SBATCH -n 44<br />
#SBATCH --ntasks-per-node=44<br />
#SBATCH --mem-per-cpu=4250<br />
#SBATCH --mail-user=prueba@nlhpc.cl<br />
#SBATCH --mail-type=ALL<br />
#SBATCH -o hello-world_%j.out<br />
#SBATCH -e hello-world_%j.err<br />
<br />
#Modulos Necesarios<br />
ml purge<br />
ml intel/2022.00<br />
ml singularityCE<br />
<br />
#Creación de carpeta<br />
mkdir -p /tmp/singularityce/singularity/mnt/session<br />
<br />
#Comandos<br />
srun singularity run hello-world_latest.sif<br />
</pre><br />
<br />
Lanzar script:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ sbatch script_44cores.sh<br />
Submitted batch job 19051335<br />
</pre><br />
<br />
Revisar estado del trabajo:<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
19051335 general Hello-wo prueba R 0:12 1 sn045<br />
</pre><br />
<br />
Revisar estado de simulación: (trabajo finalizado correctamente)<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ squeue<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
</pre><br />
<br />
<br />
Revisión de inicio del trabajo mediante correo:<br />
<br />
[[Archivo:Inicio Trabajo 19051335.jpg|no]]<br />
<br />
<br />
<br />
Revisión de finalización de trabajo mediante correo:<br />
<br />
[[Archivo:Finalización Trabajo 19051335.jpg|no]]<br />
<br />
<br />
La tarea fue ejecutada en 3 minutos con 04 segundos.<br />
<br />
Resultados de la tarea (se generan 2 archivos, 1 archivo error y un 1 archivo de salida):<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ ll<br />
total 61204<br />
-rw-r--r-- 1 prueba nlhpc 3872 Jul 30 11:31 hello-world_19051335.err<br />
-rw-r--r-- 1 prueba nlhpc 572 Jul 30 11:31 hello-world_19051335.out<br />
-rwxr-xr-x 1 prueba nlhpc 62652447 Jul 30 11:16 hello-world_latest.sif<br />
-rwxr-xr-x 1 prueba nlhpc 405 Jul 30 11:30 script_44cores.sh<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.out:<br />
<br />
Aquí podemos ver que la ejecución nos entregó como resultado 44 veces la ejecución del contenedor (la simulación fue ejecutada de forma correcta).<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.out<br />
44 hello-world_19051335.out<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.out<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
Tacotacotaco<br />
...<br />
</pre><br />
<br />
Resumen de archivo hello-world_19051335.err:<br />
<br />
Aquí podemos ver que Singularity convirtió la imagen 44 veces y limpio la imagen 44 veces.<br />
<pre><br />
prueba@leftraru1:~/Ejemplo$ wc -l hello-world_19051335.err<br />
88 hello-world_19051335.err<br />
prueba@leftraru1:~/Ejemplo$ cat hello-world_19051335.err<br />
Resumen<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Convert SIF file to sandbox...<br />
INFO: Cleaning up image...<br />
INFO: Cleaning up image...<br />
<br />
<br />
</pre><br />
<br />
== Contenedores GPU AMD MI210 ==<br />
Contamos con un directorio especial que contiene una serie de imágenes listas para ser ejecutadas en las GPU AMD MI210. Basta con cargar el módulo de Singularity:<br />
<br />
<pre> <br />
ml singularityCE/3.10.3 <br />
[modules@leftraru1 ~]$ ls $IMAGES<br />
chroma_3.43.0.sif nwchem.sif ryzen-ai-tensorflow2_latest.sif<br />
cp2k_2022.2.amd3.sif openfoam_2206.1.amd3.sif ryzen-ai-tensorflow_latest.sif<br />
grid_0.8.2-20211213.sif openmm_7.7.0_49.sif specfem3d_9c0626d1-20201122.sif<br />
gromacs_2022.3.amd1_174.sif petsc_3.18.amd4.sif specfem3d_globe_1ee10977-20210321.sif<br />
lammps_2022.5.04_130.sif pyfr_1.14.0_48.sif trilinos_1.7.sif<br />
namd_2.15a2-20211101.sif relion_4.0.sif uif-pytorch_uif1.2_rocm5.6.1_vai3.5_py3.8_pytorch1.13.sif<br />
namd3_3.0a9.sif ryzen-ai-pytorch_latest.sif uif-tensorflow_uif1.2_rocm5.6.1_vai3.5_tensorflow2.12.sif<br />
</pre><br />
<br />
<br />
</pre></div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Tutorial_de_acceso_a_Leftraru_via_SSH&diff=511Tutorial de acceso a Leftraru via SSH2023-01-11T13:40:07Z<p>Eguerra: </p>
<hr />
<div>== Ejemplos de conexión ==<br />
Para realizar una conexión desde un sistema GNU/Linux o MacOSX, use el comando SSH (ejemplo con usuario "prueba"):<br />
<pre><br />
$ ssh prueba@leftraru.nlhpc.cl<br />
prueba@leftraru.nlhpc.cl password: <br />
<br />
[...]<br />
<br />
prueba@leftraru4:~$ <br />
</pre><br />
<br />
Para conectar desde sistemas Windows, se recomienda usar Putty como cliente SSH:<br />
<br />
[[Archivo:Putty.jpg|no]]<br />
<br />
<br />
En este ejemplo, se usará el usuario "prueba".<br />
<br />
[[Archivo:Accesologin1.png|no]]<br />
<br />
<br />
El password es ingresado sin mostrar ningún carácter en la pantalla.<br />
<br />
== Acceso utilizando llaves (Recomendado) ==<br />
La autenticación con clave pública es un método de seguridad alternativo a las contraseñas, mucho más difícil de hackear y, por lo tanto, más seguro. Este método de autenticación es recomendable usarlo para acceder a servidores.<br />
<br />
La clave SSH consiste en la generación de un par de claves que proporcionan dos largas cadenas de caracteres, una pública y una privada. La clave pública se instala en cualquier servidor y luego se desbloquea mediante la conexión con un cliente SSH que hace uso de la clave privada. Si las dos claves coinciden, el servidor SSH permite el acceso sin necesidad de utilizar una contraseña. No obstante, para añadir una capa de seguridad adicional, siempre podemos aumentar la protección de la clave privada usando una contraseña.<br />
<br />
Para crear el par de claves utilice el siguiente comando:<br />
<br />
<pre><br />
[prueba@leftraru1 ~]$ ssh-keygen -t ed25519<br />
</pre><br />
<br />
Tras ejecutar el comando obtendremos la siguiente respuesta:<br />
<br />
<pre><br />
Generating public/private ed25519 key pair.<br />
</pre><br />
<br />
Una vez ejecutada la instrucción para generar las claves, se nos pedirá que indiquemos la ruta en la que queremos almacenar la clave:<br />
<br />
<pre><br />
Enter file in which to save the key (/home/prueba/.ssh/id_ed25519):<br />
</pre><br />
<br />
Tras indicar la ruta en la que se almacenará la clave, lo siguiente que tendremos que hacer es indicar una contraseña (puede dejar vacío para acceso directo):<br />
<br />
<pre><br />
Enter passphrase (empty for no passphrase):<br />
</pre><br />
<br />
Finalmente debemos copiar nuestra llave pública al cluster:<br />
<br />
<pre><br />
[prueba@leftraru1 ~] ssh-copy-id leftraru.nlhpc.cl<br />
Number of key(s) added: 1<br />
<br />
Now try logging into the machine, with: "ssh 'leftraru.nlhpc.cl'"<br />
and check to make sure that only the key(s) you wanted were added.<br />
</pre><br />
<br />
Ahora ya podremos conectarnos directamente con nuestras llaves:<br />
<br />
<pre><br />
[prueba@leftraru1 ~] ssh leftraru.nlhpc.cl<br />
</pre><br />
<br />
== Cambiar contraseña ==<br />
Para cambiar la contraseña de usuario, es necesario que esta cumpla con ciertos requisitos como por ejemplo:<br />
<br />
* El mínimo de caracteres son 10.<br />
* Debe ser alfanumérica.<br />
* Tener 3 caracteres especiales (al menos 1 mayúscula – 1 minúscula y 1 número).<br />
<br />
Para ejecutar esta acción, utilice el siguiente comando:<br />
<pre><br />
[prueba@leftraru1 ~]$ passwd<br />
<br />
Changing password for user prueba.<br />
(current) LDAP Password: <- Ingrese su contraseña actual.<br />
<br />
New password: ********* <- Ingrese su nueva contraseña.<br />
<br />
Retype new password: Reingrese su nueva contraseña.<br />
<br />
passwd: all authentication tokens updated successfully.<br />
</pre><br />
<br />
Confirmación de cambio de clave exitoso, le recomendamos cerrar su sesión e ingresar nuevamente a nuestro sistema ingresando su nueva contraseña.<br />
<br />
== Conexión a nodos actualmente utilizados ==<br />
Algunas veces, por distintas circunstancias, sería deseable tener la posibilidad de ingresar al nodo donde se estén ejecutando nuestras tareas con tal de verificar su estado, comprobar ciertos valores, etc.<br />
<br />
Pensado en la comodidad de los usuarios, se ha implementado un módulo del gestor que colas SLURM que permite esta funcionalidad. Por tanto, el login será permitido en todas aquellas máquinas donde actualmente exista un trabajo nuestro.<br />
<br />
Por ejemplo; nuestra tarea de prueba 'tarea_test.sh' ha sido enviada a la cola y ha ingresado con el ID '3469576'. Slurm reservó el nodo 'cn053' para llevar a cabo la ejecución, por tanto el usuario tiene permitido el ingreso mediante ssh al nodo:<br />
<br />
<pre><br />
leftraru$ sbatch tarea_test.sh<br />
leftraru$ squeue<br />
<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
3469576 slims Prueba test R 1:57 1 cn053<br />
<br />
leftraru$ ssh cn053<br />
Last login: today 2016 from leftraru.nlhpc.cl<br />
cn053$<br />
</pre><br />
<br />
Tenga en cuenta que aún se mantiene la restricción de ingreso para el resto de los nodos:<br />
<pre><br />
leftraru$ ssh cn001<br />
Access denied: user test (uid=000) has no active jobs on this node.<br />
leftraru$<br />
</pre><br />
<br />
== Nodos Login ==<br />
Aunque disponemos de 4 nodos para el acceso al clúster por parte de los usuarios, en general, hay que usar el nombre:<br />
<br />
* leftraru.nlhpc.cl<br />
<br />
A la hora de conectarse por SSH al clúster. Al acceder a esa dirección se consigue que los usuarios queden conectados aleatoriamente a los nodos login.<br />
<br />
Pero si resultara necesario, se puede acceder a un nodo login específicamente usando su nombre a la hora de realizar la conexión SSH:<br />
<br />
* leftraru1.nlhpc.cl<br />
* leftraru2.nlhpc.cl<br />
* leftraru3.nlhpc.cl<br />
* leftraru4.nlhpc.cl<br />
<br />
== Notas ==<br />
Debido a que leftraru balancea la carga de los nodos Login se debe evitar el uso de screen, ya que no se garantiza el acceso al mismo nodo que tenía la sesión screen abierta una vez que el usuario cierra su sesión.<br />
<br />
Un usuario sólo podrá acceder por ssh a los cuatro nodos logins y a los nodos de cómputo en los cuales tenga alguna tarea en ejecución mediante nuestro sistema gestor de colas SLURM.<br />
<br />
'''Si falla muchas veces el intento de login por SSH o genera muchas conexiones, su IP podría ser bloqueada. Contacte por correo electrónico con Soporte si tiene problemas de conexión: '''[mailto:soporte@nlhpc.cl soporte@nlhpc.cl]'''</div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Tutorial_de_acceso_a_Leftraru_via_SSH&diff=510Tutorial de acceso a Leftraru via SSH2023-01-11T11:41:55Z<p>Eguerra: </p>
<hr />
<div>== Ejemplos de conexión ==<br />
Para realizar una conexión desde un sistema GNU/Linux o MacOSX, use el comando SSH (ejemplo con usuario "prueba"):<br />
<pre><br />
$ ssh prueba@leftraru.nlhpc.cl<br />
prueba@leftraru.nlhpc.cl password: <br />
<br />
[...]<br />
<br />
prueba@leftraru4:~$ <br />
</pre><br />
<br />
Para conectar desde sistemas Windows, se recomienda usar Putty como cliente SSH:<br />
<br />
[[Archivo:Putty.jpg|no]]<br />
<br />
<br />
En este ejemplo, se usará el usuario "prueba".<br />
<br />
[[Archivo:Accesologin1.png|no]]<br />
<br />
<br />
El password es ingresado sin mostrar ningún carácter en la pantalla.<br />
<br />
== Acceso utilizando llaves (Recomendado) ==<br />
La autenticación con clave pública es un método de seguridad alternativo a las contraseñas, mucho más difícil de hackear y, por lo tanto, más seguro. Este método de autenticación es recomendable usarlo para acceder a servidores.<br />
<br />
La clave SSH consiste en la generación de un par de claves que proporcionan dos largas cadenas de caracteres, una pública y una privada. La clave pública se instala en cualquier servidor y luego se desbloquea mediante la conexión con un cliente SSH que hace uso de la clave privada. Si las dos claves coinciden, el servidor SSH permite el acceso sin necesidad de utilizar una contraseña. No obstante, para añadir una capa de seguridad adicional, siempre podemos aumentar la protección de la clave privada usando una contraseña.<br />
<br />
Para crear el par de claves utilice el siguiente comando:<br />
<br />
<pre><br />
[prueba@leftraru1 ~]$ ssh-keygen -t ed25519<br />
</pre><br />
<br />
Tras ejecutar el comando obtendremos la siguiente respuesta:<br />
<br />
<pre><br />
Generating public/private ed25519 key pair.<br />
</pre><br />
<br />
Una vez ejecutada la instrucción para generar las claves, se nos pedirá que indiquemos la ruta en la que queremos almacenar la clave:<br />
<br />
<pre><br />
Enter file in which to save the key (/home/prueba/.ssh/id_ed25519):<br />
</pre><br />
<br />
Tras indicar la ruta en la que se almacenará la clave, lo siguiente que tendremos que hacer es indicar una contraseña (se recomienda dejar vacio para acceso directo):<br />
<br />
<pre><br />
Enter passphrase (empty for no passphrase):<br />
</pre><br />
<br />
Finalmente debemos copiar nuestra llave pública al cluster:<br />
<br />
<pre><br />
[prueba@leftraru1 ~] ssh-copy-id leftraru.nlhpc.cl<br />
Number of key(s) added: 1<br />
<br />
Now try logging into the machine, with: "ssh 'leftraru.nlhpc.cl'"<br />
and check to make sure that only the key(s) you wanted were added.<br />
</pre><br />
<br />
Ahora ya podremos conectarnos directamente con nuestras llaves:<br />
<br />
<pre><br />
[prueba@leftraru1 ~] ssh leftraru.nlhpc.cl<br />
</pre><br />
<br />
== Cambiar contraseña ==<br />
Para cambiar la contraseña de usuario, es necesario que esta cumpla con ciertos requisitos como por ejemplo:<br />
<br />
* El mínimo de caracteres son 10.<br />
* Debe ser alfanumérica.<br />
* Tener 3 caracteres especiales (al menos 1 mayúscula – 1 minúscula y 1 número).<br />
<br />
Para ejecutar esta acción, utilice el siguiente comando:<br />
<pre><br />
[prueba@leftraru1 ~]$ passwd<br />
<br />
Changing password for user prueba.<br />
(current) LDAP Password: <- Ingrese su contraseña actual.<br />
<br />
New password: ********* <- Ingrese su nueva contraseña.<br />
<br />
Retype new password: Reingrese su nueva contraseña.<br />
<br />
passwd: all authentication tokens updated successfully.<br />
</pre><br />
<br />
Confirmación de cambio de clave exitoso, le recomendamos cerrar su sesión e ingresar nuevamente a nuestro sistema ingresando su nueva contraseña.<br />
<br />
== Conexión a nodos actualmente utilizados ==<br />
Algunas veces, por distintas circunstancias, sería deseable tener la posibilidad de ingresar al nodo donde se estén ejecutando nuestras tareas con tal de verificar su estado, comprobar ciertos valores, etc.<br />
<br />
Pensado en la comodidad de los usuarios, se ha implementado un módulo del gestor que colas SLURM que permite esta funcionalidad. Por tanto, el login será permitido en todas aquellas máquinas donde actualmente exista un trabajo nuestro.<br />
<br />
Por ejemplo; nuestra tarea de prueba 'tarea_test.sh' ha sido enviada a la cola y ha ingresado con el ID '3469576'. Slurm reservó el nodo 'cn053' para llevar a cabo la ejecución, por tanto el usuario tiene permitido el ingreso mediante ssh al nodo:<br />
<br />
<pre><br />
leftraru$ sbatch tarea_test.sh<br />
leftraru$ squeue<br />
<br />
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)<br />
3469576 slims Prueba test R 1:57 1 cn053<br />
<br />
leftraru$ ssh cn053<br />
Last login: today 2016 from leftraru.nlhpc.cl<br />
cn053$<br />
</pre><br />
<br />
Tenga en cuenta que aún se mantiene la restricción de ingreso para el resto de los nodos:<br />
<pre><br />
leftraru$ ssh cn001<br />
Access denied: user test (uid=000) has no active jobs on this node.<br />
leftraru$<br />
</pre><br />
<br />
== Nodos Login ==<br />
Aunque disponemos de 4 nodos para el acceso al clúster por parte de los usuarios, en general, hay que usar el nombre:<br />
<br />
* leftraru.nlhpc.cl<br />
<br />
A la hora de conectarse por SSH al clúster. Al acceder a esa dirección se consigue que los usuarios queden conectados aleatoriamente a los nodos login.<br />
<br />
Pero si resultara necesario, se puede acceder a un nodo login específicamente usando su nombre a la hora de realizar la conexión SSH:<br />
<br />
* leftraru1.nlhpc.cl<br />
* leftraru2.nlhpc.cl<br />
* leftraru3.nlhpc.cl<br />
* leftraru4.nlhpc.cl<br />
<br />
== Notas ==<br />
Debido a que leftraru balancea la carga de los nodos Login se debe evitar el uso de screen, ya que no se garantiza el acceso al mismo nodo que tenía la sesión screen abierta una vez que el usuario cierra su sesión.<br />
<br />
Un usuario sólo podrá acceder por ssh a los cuatro nodos logins y a los nodos de cómputo en los cuales tenga alguna tarea en ejecución mediante nuestro sistema gestor de colas SLURM.<br />
<br />
'''Si falla muchas veces el intento de login por SSH o genera muchas conexiones, su IP podría ser bloqueada. Contacte por correo electrónico con Soporte si tiene problemas de conexión: '''[mailto:soporte@nlhpc.cl soporte@nlhpc.cl]'''</div>Eguerrahttps://wiki.nlhpc.cl/index.php?title=Sumario&diff=499Sumario2022-11-30T11:54:58Z<p>Eguerra: </p>
<hr />
<div>== Información para nuevos usuarios ==<br />
Esta es la wiki de usuarios de Leftraru, el clúster HPC del NLHPC. Aquí encontrará información útil para:<br />
<br />
* Ingresar al clúster<br />
* Descripción del hardware<br />
* Lanzar tareas en el gestor de recursos Slurm<br />
* Preguntas Frecuentes<br />
* Para más información puede visitar [https://wiki.nlhpc.cl/Informaci%C3%B3n_para_nuevos_usuarios Aquí]<br />
<br />
== Recursos computacionales de leftraru ==<br />
Leftraru cuenta actualmente con 5 particiones: general, largemem, gpus, slims y debug.<br />
<br />
Las caracterísiticas de estas particiones pueden encontrarse en [https://wiki.nlhpc.cl/Hardware_Disponible Recursos Computacionales NLHPC]<br />
<br />
== Creación de cuentas ==<br />
El proceso de creación de cuentas es relativamente fácil. Para poder crear una cuenta debe seguir las instrucciones del siguiente [http://www.nlhpc.cl/es/servicios enlace] y luego postular a una cuenta rellenando información en un formulario online.<br />
<br />
== Software instalado en el Clúster ==<br />
Leftraru cuenta con una amplia gama de software.<br />
<br />
Para saber el software que está instalado en nuestro clúster, vaya al siguiente link: [https://wiki.nlhpc.cl/Lmod Lmod]<br />
<br />
Tenga en cuenta que el NLHPC no entrega licencias de software, por lo que es responsabilidad de cada usuario o grupo de usuarios el adquirir estas licencias.<br />
<br />
== Accediendo a Leftraru ==<br />
Leftraru está basado en la distribución Centos Linux. Uiliza el protocolo [https://es.wikipedia.org/wiki/Secure_Shell SSH] para conectase remotamente. Puede conectarse a Leftraru en la siguiente dirección:<br />
<br />
leftraru.nlhpc.cl <br />
<br />
Puede encontrar mayor información en [https://wiki.nlhpc.cl/Tutorial_de_acceso_a_Leftraru_via_SSH Tutorial de acceso a Leftraru via SSH]. Para facilitar la copia de archivos en Leftraru, vea el [https://wiki.nlhpc.cl/Tutorial_de_acceso_a_archivos Tutorial de acceso a archivos]<br />
<br />
== MFA o autenticación multifactor == <br />
MFA o autenticación multifactor agrega una capa de protección al proceso de inicio de sesión. En el caso del NLHPC, se ha decidido integrar MFA adicionalmente al uso de contraseñas y llaves. El proceso de creación de MFA se ejecutará automáticamente cuando inicie sesión y es necesario que tenga a la mano su celular con la aplicación Google Authenticator o Authy instalada. Cuando inicie sesión, se mostrará un código qr que deberá escanear en alguna de estas aplicaciones. También se mostrarán un “secret key” que le permitirá recuperar el acceso en el caso de extravío de su celular. La próxima vez que inicie sesión en su cuenta se pedirá tanto la contraseña de acceso como el código generado por la aplicación multifactor.<br />
<br />
== Slurm, sistema de gestión de recursos ==<br />
Leftraru utiliza [https://slurm.schedmd.com/ Slurm] como gestor de recursos. Slurm provee de un framework para encolar trabajos, asignación de nodos de cómputo, reserva de tiempo de CPU, ejecución y gestión de trabajos dentro de clúster. Nuestros nodos de cómputo se encuentran agrupados en particiones, dentro de las cuales los usuarios pueden ejecutar sus trabajos dependiendo de sus necesidades.<br />
<br />
Para ver más información acerca de cómo trabajar con Slurm en el clúster, por favor visite el tutorial de [https://wiki.nlhpc.cl/SISTEMA_GESTOR_DE_RECURSOS ejecución de tareas dentro de Leftaru.]<br />
<br />
== Lustre, sistema de archivos distribuido ==<br />
[https://es.wikipedia.org/wiki/Lustre_%28sistema_de_archivos%29 Lustre] es un conocido [https://es.wikipedia.org/wiki/Sistema_de_archivos_distribuido sistema de archivos distribuido] de alta disponibilidad que permite usar una red de computadores para construir un espacio de almacenamiento amplio, escalable y mantenible en el que se pueden definir cuotas de utilización por usuario.<br />
<br />
Lustre es open source, pero debido a su envergadura y dificultad para constituirlo, se ha optado por contratar una solución privada (a la empresa [http://www.ddn.com/ DDN]) que incluye tanto infraestructura como configuraciones optimizadas de tal manera de contar con una opción de almacenamiento acorde a las necesidades del NLHPC.<br />
<br />
'''Limitaciones y excepciones de Lustre:''' A pesar de tener muchas características sobresalientes, y en pos de aumentar el rendimiento de la lectura y escritura de archivos, Lustre no permite bloquear un archivo ([https://en.wikipedia.org/wiki/File_locking file locking] en inglés). Esto implica que muchos de los motores de bases de datos más conocidos (MySQL, Postgres, etc.) e incluso algunas aplicaciones que hacen uso de esta característica no funcionen o se caigan en su ejecución. Se recomienda realizar esa parte del trabajo en la partición /mnt/flock/usuario.<br />
<br />
== Tutoriales ==<br />
[https://wiki.nlhpc.cl/Tutorial_de_acceso_a_Leftraru_via_SSH Tutorial de acceso a Leftraru via SSH]<br />
<br />
[https://wiki.nlhpc.cl/SISTEMA_GESTOR_DE_RECURSOS Ejecución de tareas dentro de Leftaru]<br />
<br />
Presentación uso Leftraru<br />
<br />
[https://wiki.nlhpc.cl/Escalamiento Escalamiento de Aplicaciones]<br />
<br />
[https://wiki.nlhpc.cl/Monitoreo_De_Tareas Monitoreo De Tareas]<br />
<br />
[https://wiki.nlhpc.cl/Categor%C3%ADa:Software Documentación de temas relacionados con el software del clúster]</div>Eguerra