Información y ayuda

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
~~NOTOC~~

====== Guía de Usuario del HPC UO ======

Esta guía ha sido confeccionada con el objetivo de orientar a los usuarios en el trabajo con el HPC UO. Se recomienda una lectura cuidadosa de la misma, especialmente a los usuarios nuevos.

===== Referencia en Publicaciones =====

Se solicita a los usuarios que las publicaciones y tesis que resulten por el uso de los recursos del HPC UO incluyan como referencia:

**"Esta investigación se realizó  en la Supercomputadora de la Universidad de Oriente que forma parte del Centro Cubano de Supercomputación (HPC-Cuba) con el apoyo del proyecto VLIR-UOS JOINT y la Red Iberoamericana de Supercomputación (RICAP)"**.

**"This research was carried out in the Supercomputer of the Universidad de Oriente, which is part of the Cuban Supercomputing Center (HPC-Cuba) with the support of the VLIR-UOS JOINT project and the Ibero-American Supercomputing Network (RICAP)"**.
===== Soporte técnico a los usuarios =====

El Equipo de Administración del HPC UO brinda soporte técnico a los usuarios sobre el trabajo en el clúster. 

Para los usuarios de la Universidad de Oriente (UO), el soporte se realiza mediante el [[https://reportes.uo.edu.cu|Sistema de Reportes o Tickets]], usando el //Tema de ayuda//: HPC-UO. Para enviar un reporte hay que identificarse con el nombre de usuario y contraseña utilizados para acceder a los servicios informáticos de la UO. Se solicita a estos usuarios que no envíen directamente sus preguntas a los administradores, sino a través del sistema mencionado.

===== Envío de ficheros hacia y desde el HPC UO  =====

Los usuarios pueden enviar/recibir sus ficheros desde y hacia su directorio personal en el clúster (//<nowiki>/</nowiki>home<nowiki>/</nowiki>CLUSTER<nowiki>/</nowiki>nombre_usuario//) usando el [[https://portal.uo.hpc.cu/website|Portal Web]]. En el Portal el tamaño máximo del fichero es de 150 Mb.

Para enviar ficheros de cualquier tamaño:

- Los usuarios con SO GNU/Linux pueden enviar y recibir sus ficheros con el comando //scp//.

- Los usuarios con SO Windows pueden enviar y recibir sus ficheros usando [[https://winscp.net/eng/download.php|winscp]] o [[https://mobaxterm.mobatek.net/download-home-edition.html|MobaXterm]].

===== Cambio de contraseña  =====

Los usuarios pueden cambiar su contraseña a través de su Perfil de usuario en el [[https://portal.uo.hpc.cu/website|Portal Web]].

===== Nodos del HPC UO  =====

Hay 2 tipos de nodos en el clúster:

**Nodo login o nodo de conexión** 

Es el nodo para conectarse al HPC UO. Corresponde a //login.uo.hpc.cu//.

**Nodos de cálculo**

Los nodos de cálculo son el corazón del HPC UO y, como su nombre lo indica, es en ellos donde se realizan los cálculos, las operaciones, etc. solicitadas por los usuarios. Es importante que los usuarios conozcan las características de los nodos para poder solicitar  los recursos de sus trabajos.

Los nodos de cálculo del HPC UO  son servidores DELL Power Edge C6145 con procesadores AMD Opteron 6126.

^Clúster^Nodos^Cores/nodo^RAM/nodo(GB)^TFLOPS totales^Conexión|
|HPC UO |14|32|64|4.5|Infiniband 40 Gbps \\  Ethernet 1 Gbps|

===== Almacenamiento en disco =====

Las aplicaciones que se ejecutan en el HPC UO necesitan ficheros de entrada y de datos adicionales y producen ficheros de salida y ficheros temporales durante la ejecución. 

Hay dos opciones para el almacenamiento de esos ficheros: el directorio personal del usuario //<nowiki>/</nowiki>home<nowiki>/</nowiki>CLUSTER<nowiki>/</nowiki>nombre_usuario// (se referencia con la variable de entorno $HOME de Linux) y el directorio /scratch. 

^Directorio^Localización^Respaldo^Espacio|
|$HOME|red (NFS)|Si|10 GB cuota|
|/scratch|red (NFS)|No|10 GB cuota|

En el  directorio $HOME los usuarios copian sus scripts, ficheros de entrada, etc. En este directorio también se guardan los ficheros de resultados una vez concluido el cálculo. Se recomienda crear en el $HOME directorios individuales para cada trabajo que se envíe.

El directorio /scratch está dedicado a almacenar ficheros temporales generados por los programas durante su ejecución. Si lo requieren, los usuarios pueden crear un directorio con su <nombre_usuario> en el /scratch para guardar los ficheros temporales de sus programas, separados de los ficheros de otros usuarios. 

Se debe tener en cuenta que el /scratch no es respaldado en ninguna forma. Los ficheros del directorio /scratch son borrados automáticamente a los 14 días de su fecha de creación.
===== Módulos =====

Para ejecutar las aplicaciones en el HPC UO se necesita definir el camino de los ficheros binarios, las bibliotecas a usar, entre otros. Para el soporte de entorno de módulos el HPC UO emplea //Lmod//. Estos módulos permiten cambiar dinámicamente las variables de entorno y con ello probar el desempeño de una aplicación con diferentes versiones.

Para listar los módulos disponibles se ejecuta el comando:

<code>$ module available </code>

Por defecto ningún módulo es cargado. Para cargar un módulo, por ejemplo el módulo de Python:

<code>$ module load Python </code>

Si no especifica la versión, se carga la última versión.

Para cargar una versión específica:

<code>$ module load Python/2.1 </code>

Es posible listar los módulos cargados con:

<code>$ module list </code>

Otros comandos útiles son:

<code>$ module unload <module> -> desactiva un módulo previamente cargado. </code>

<code>$ module purge           -> desactiva todos los módulos cargados. </code>

<code>$ module whatis <module> -> muestra descripción del módulo. </code>

<code>$ module show <module>   -> muestra el contenido del módulo. </code> 

Para más información sobre los módulos se utiliza:

<code>$ module help </code>

=====El Administrador de Recursos=====

El HPC UO tiene una serie de recursos como particiones, nodos, sockets, cores, memoria, entre otros. Estos recursos son administrados por la herramienta Slurm (**S**imple **L**inux **U**tility for **R**esource **M**anager), que además permite enviar, planificar y monitorear los trabajos en un clúster de computadoras. 

Para enviar a ejecutar un trabajo en el HPC UO se necesita confeccionar un script en el que se especifican los recursos, los módulos, el comando de ejecución, etc. Slurm analiza los recursos solicitados y si están disponibles manda a ejecutar el trabajo. En caso contrario, Slurm pone en cola el trabajo hasta que los recursos estén disponibles. Una vez que se ejecuta el trabajo, Slurm envía un mensaje de correo al usuario, si este lo solicitó.
===== El script de Slurm =====

El script de Slurm o script de envío se confecciona por el usuario y en el mismo se incluyen una serie de directivas #SBATCH que indican los recursos que se necesitan, los módulos a cargar, el programa a ejecutar, entre otros.

Teniendo en cuenta que en Linux no existe el concepto de extensión en el nombre de los archivos, el nombre del script de envío puede terminar o no en una cadena conocida. Algunas terminaciones comunes son .sl, .sh, .x y otras. Por ejemplo, //test.sl//, //miprograma.sh//, //calculo1.x//, //calculo_pi// etc.

A continuación, se muestra un script de Slurm para el envío de un trabajo de Python que requiere 1 nodo, 1 CPU y 2 horas de tiempo de ejecución.

<code>
#!/bin/bash
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --time=00-02:00:00
# Cargar módulo
module load Python
# Ejecutar el trabajo
python test.py
</code>

El script de Slurm tiene como primera línea la especificación del shell (#!/bin/bash). Las siguientes líneas comienzan con //#SBATCH// especificando la solicitud de recursos u otra información pertinente. Las líneas diferentes a //#SBATCH// que empiezan por # corresponden a comentarios.

El script anterior es un ejemplo con un mínimo de directrices para el envío de trabajos. Solamente ejecuta el trabajo y no envía ninguna información al usuario.

Un script más completo se presenta a continuación:

<code>
#!/bin/bash
#SBATCH --partition=public     # Partición (cola) donde se ejecutará el trabajo
#SBATCH --job-name=miprograma  # Nombre del trabajo  
#SBATCH --nodes=1              # Número de nodos
#SBATCH --ntasks=1             # Número de tareas
#SBATCH --time=00-24:00:00     # Tiempo solicitado DD-HH:MM:SS
#SBATCH --output=slurm.%J.out  # Salida standard
#SBATCH --error=slurm.%J.err   # Salida de errores
#SBATCH --mail-user=           # Email del usuario
#SBATCH --mail-type=ALL        # Evento de notificación(NONE, BEGIN, END, FAIL, ALL)

# Cambiar para el directorio de envío del trabajo 
cd $SLURM_SUBMIT_DIR 	

# Cargar módulo
module load Python

# Ejecutar el programa
python test.py
</code>

En el script anterior se han añadido el nombre del trabajo, el fichero de salida, el fichero de error, así como el nombre del usuario para que Slurm envíe alertas por correo electrónico cuando el trabajo empieza, aborta y finaliza. También se indica cambiar para el directorio desde donde se envía el trabajo y cargar el módulo correspondiente. Finalmente se ordena ejecutar el programa. 

El fichero especificado en #SBATCH <nowiki>--</nowiki>error= es importante para ver los errores que pueden ocurrir durante la ejecución y, posteriormente, analizar la causa de los mismos.

En el script de envío también se debe especificar el tiempo de ejecución con #SBATCH <nowiki>--</nowiki>time= con un valor estimado por el usuario. Si no se especifica el tiempo con #SBATCH <nowiki>--</nowiki>time=, se toma el tiempo máximo definido para la partición.

Hay que notar que la directiva #SBATCH <nowiki>--</nowiki>partition= especifica la **cola de trabajos**. En el HPC UO hay 2 colas, que en el caso de Slurm corresponden a las particiones:

^Cola^Tiempo Máximo^Max. Trabajos en ejecución^Max. Trabajos enviados^Recursos|
|public*|5 días | | |13 nodos, 416 cores CPU|
|gpu| | | |1 nodo con \\ 4 cores CPU \\ 2560 cores GPU|

La **cola public** se usa para realizar cálculos con CPU. Tiene 13 nodos con 32 cores cada uno, en total 416 cores. Esta es la cola por defecto, es decir, que si no se especifica en el script la directiva #SBATCH <nowiki>--</nowiki>partition=, el trabajo va la cola //public//.

La **cola gpu** se usa para realizar cálculos con GPU. Tiene un nodo con una tarjeta Tesla M10, con 4 procesadores GMX107 y un total de 2560 CUDA cores.

En el futuro en ambas colas se especificarán los tiempos máximos, el número máximo de los trabajos en ejecución y el número máximo de trabajos que puede enviar un usuario.

Finalmente, en el script de envío se pueden incluir otras opciones además de las señaladas en esta guía como la memoria requerida, nodos específicos a usar, etc. Todas las opciones que se pueden utilizar en el script de envío se pueden obtener con el comando //man sbatch//.

===== Confección del script de Slurm vía http =====

Generalmente el script se confecciona con un editor de texto. Se puede utilizar como modelo el script mostrado anteriormente, cambiando los datos por los valores particulares de cada trabajo del usuario.
 
Sin embargo, para algunos usuarios la edición textual resulta un poco engorrosa. Por ello, se ha incluido en el [[https://portal.uo.hpc.cu/website|Portal Web]] un **Generador de Script** en el cual se pueden ingresar los datos de forma  interactiva y, al final, obtener el script redactado.

Es importante notar que este generador no incluye todas las opciones que se pueden usar en los scripts. Ha sido confeccionado para los usuarios nuevos, especialmente los que utilizan con frecuencia el SO Windows, para facilitarles el inicio de su trabajo en el HPC UO. Luego con más experiencia y habilidad los usuarios nuevos pueden confeccionar el script editando un fichero texto.

===== Comandos de Slurm =====

Slurm ofrece una serie de {{ :wiki:summary.pdf |comandos}} que permiten el envío y monitoreo de los trabajos, la modificación de los recursos solicitados, entre otros.

^Comando^Función|
|sbatch [job_script]|Envío de trabajo|
|squeue|Estado del trabajo/cola|
|scancel [job_id]|Borrar trabajo|
|scontrol show nodes|Mostrar los nodos|
|scontrol hold [job_id]|Retener un trabajo|
|scontrol release [job_id]|Liberar un trabajo previamente retenido|
|sinfo| Mostrar información de los nodos y particiones|
|salloc|Asignar nodos|
|srun|Lanzar un paso de un trabajo (paralelo)|
|sacct|Muestra la información de contabilidad de un trabajo|

**sbatch**

El comando //sbatch// se usa para enviar un trabajo a la cola. Puede aceptar una serie de opciones desde la línea de comando o más típicamente desde un script de Slurm. Por ejemplo, para enviar el script //miscript.sl// se escribe:

<code>$ sbatch miscript.sl</code>

Opcionalmente, cualquier directiva #SBATCH puede ser eliminada del script con una opción equivalente en la línea de comando. Por ejemplo, si se elimina de //miscript.sl// la directiva #SBATCH <nowiki>--</nowiki>ntasks=1, el usuario puede especificar 4 tareas totales usando la línea de comando: 

<code>$ sbatch --ntasks=4 miscript.sl</code>

Para más información ejecutar el comando //man sbatch//.

**sinfo**

El comando //sinfo// muestra información sobre los nodos y particiones.

<code>
$ sinfo
PARTITION   AVAIL   TIMELIMIT   NODES   STATE   NODELIST
public*     up      5-00:00:00  2       mix     nodo[001-002]
public*     up      5-00:00:00  7       alloc   nodo[004-009,013]
public*     up      5-00:00:00  4       idle    nodo[003,010-012]
gpu         up      infinite    1       mix     nodo014
</code>

La información anterior significa que la partición //public// tiene 13 nodos (//nodo001//, //nodo002// ... //nodo013//), de los cuales 7 están asignados completamente a trabajos (//alloc//), 4 están libres (//idle//) y los restantes tienen algunas de sus CPU asignadas mientras que otras están libres (//mix//). La partición //gpu// tiene un nodo //nodo014//, que se encuentra en estado //mix//.

La cola por defecto se indica con un asterisco*. Esta es la utilizada por Slurm si el usuario no indica la directiva #SBATCH <nowiki>--</nowiki>partition= en el script. 

Para más información ejecutar el comando //man sinfo//.

**squeue**

El comando //squeue// se utiliza para ver el estado de la cola de trabajos.

<code>
$ squeue
JOBID  PARTITION     NAME        USER          ST       TIME      NODES    NODELIST(REASON)
203    public       testGen2     uo_artigas    PD       0:00       12        (Resources)
199    public       testGen1     uo_artigas    R        20:30:21   12         nodo00[2-6]
214    gpu          1ten         uo_oscar      R        6:21       1          nodo014
</code>

La información anterior de la cola muestra los id de los trabajos, la partición donde se están ejecutando, el nombre del trabajo, el usuario que lo envió, el estado (PD=pendiente, R=ejecutándose), el tiempo de ejecución, el número de nodos y la lista de nodo o la razón por la cual están pendientes. 

Para obtener más información se puede utilizar el comando //man squeue//.

**scontrol**

El comando //scontrol// se usa para monitorear y modificar los trabajos de la cola. Es uno de los comandos más poderosos de Slurm. Por ejemplo:

Para ver las particiones:

<code>
$ scontrol show partitions
   PartitionName=public
   AllowGroups=ALL AllowAccounts=ALL AllowQos=ALL
   AllocNodes=ALL Default=YES DefaultTime=NONE MaxTime=5-00:00:00 
   Nodes=nodo0[01-13]
   PriorityJobFactor=1 State=UP TotalCPUs=416 TotalNodes=13 DefMemPerNode=UNLIMITED
   PartitionName=gpu
   AllowGroups=ALL AllowAccounts=ALL AllowQos=ALL
   AllocNodes=ALL Default=NO DefaultTime=NONE MaxTime=UNLIMITED
   Nodes=nodo014
   PriorityJobFactor=1 State=UP TotalCPUs=4 TotalNodes=1 DefMemPerNode=UNLIMITED
</code>

Para ver la información de los trabajos:

<code>$ scontrol show job 115</code>

**scancel**

El comando //scancel// se utiliza para cancelar un trabajo, en este caso el trabajo con identificador 115:

<code>$ scancel job 115</code>

**srun**

El comando //srun// ejecuta trabajos paralelos. Es la versión en Slurm de //mpirun//. Típicamente se invoca desde un script de Slurm para ejecutar un trabajo MPI. Al usar //srun//, la aplicación debe tener un código MPI para que se ejecute en paralelo a través de múltiples núcleos de CPU. Si se utiliza //srun// en un comando o  ejecutable no-MPI el programa se ejecutará independientemente X veces en cada uno de los núcleos de CPU.

Otra forma de usar //srun// es ejecutarlo directamente desde la línea de comandos, en este caso //srun// primero asigna un recurso para ejecutar el trabajo. La opción -n [CPU_núcleos] especifica el número de núcleos de CPU para lanzar el trabajo paralelo. Por ejemplo, el siguiente comando obtiene un recurso con 16 núcleos de CPU y luego ejecuta el comando //hostname// en esos núcleos:

<code>$ srun -n 16 hostname</code>

Para más información se puede utilizar el comando //man srun//.
===== Variables de Entorno de Slurm =====

Slurm tiene una serie de variables de entorno, las cuales pueden ser muy útiles a la hora de crear los scripts.

Para referenciarlas dentro de un script se le antepone el símbolo $ (por ejemplo $SLURM_SUBMIT_DIR).

Las variables son las siguientes:

^Variable^Significado|
|SLURM_JOBID|ID del trabajo|
|SLURM_SUBMIT_DIR    |Directorio de envío del trabajo|
|SLURM_SUBMIT_HOST	|Nombre del host desde el que se envió el trabajo|
|SLURM_JOB_NODELIST	|Nombre de los hosts asignados al trabajo|
|SLURM_ARRAY_TASK_ID	|ID de la tarea en el arreglo del trabajo|
|SLURM_JOB_CPUS_PER_NODE	|Núcleos de CPU por nodo asignados al trabajo|
|SLURM_NNODES	|Número de nodos asignados al trabajo|

Una lista completa de las variables de entorno de Slurm puede encontrarse en http://slurm.schedmd.com/sbatch.html.

===== Trabajos con aplicaciones =====

A continuación se listan ejemplos de scripts de Slurm para diferentes tipos de trabajos o aplicaciones.

  * [[hpc-script-serie|Trabajo en serie]]
  * [[hpc-script-openmpi|Trabajo MPI (Message Passing Interface)]]
  * [[hpc-script-openmp|Trabajo OpenMP o SMP (Symmetric Multi-Processing)]]
  * [[hpc-script-hibrido|Trabajo Híbrido (OpenMPI + OpenMP)]]
  * [[hpc-script-condicion|Trabajos con Condición]]
  * [[hpc-script-array|Arreglos de trabajos]]
  * [[hpc-script-amber|Amber]]
  * [[hpc-script-autodock|Autodock]]
  * [[hpc-script-autodockvina|Autodock Vina]]
  * [[hpc-script-blender|Blender]]
  * [[hpc-script-foamextend|foam-extend]]
  * [[hpc-script-fortranc|Fortran/C++]]
  * [[hpc-script-ffmpeg|FFmpeg]]
  * [[hpc-script-gaussian|Gaussian]]
  * [[hpc-script-gulp|GULP]]
  * [[hpc-script-julia|Julia]]
  * [[hpc-script-lammps|LAMMPS]]
  * [[hpc-script-octave|Octave]]
  * [[hpc-trabajo-python|Python]]
  * [[hpc-grafico-python|Gráficos con Python]]
  * [[hpc-script-pytorch|Pytorch]]
  * [[hpc-script-r|R]]
  * [[hpc-script-tensorflow|Tensorflow]]
  * [[hpc-script-vc|Visión por Computadora con CPU]]
===== Trabajo con GPU =====

Los cálculos con GPU se realizan en el //nodo014// de la partición //gpu//. Este nodo tiene instalada una tarjeta NVIDIA Tesla M10 cuyos datos principales son:

^Arquitecture^Maxwell|
|GPUs per board|4 (GPU 0,1,2,3)|
|Cores|2560 (640 por GPU)|
|GPU Memory|32GB (8 por GPU)|
|Core clock|1.03 GHz|
|Compute capability|5|
|CUDA driver version: 10.2|10.2|
|Streaming Multiprocessors (SM)|5|
|Threads per SM|2024|
|Rendimiento teórico:|FP32(float)=1.672 \\ TFLOPS FP64(double)=64.24 GFLOPS|

Debido a que actualmente el HPC UO solo cuenta con una GPU, se ha decidido que por el momento los usuarios que deseen calcular con ella tienen que solicitarlo a través del [[https://reportes.uo.edu.cu|Sistema de Reportes]].

La GPU puede ser usada para:

- Cálculos de aplicaciones de terceros compiladas para GPU

- Cálculos con programas en paralelo hechos por los propios usuarios en diferentes lenguajes de programación (CUDA, Python, C/C++, entre otros).

El envío de los programas GPU se realiza con el comando //sbatch <nombre_programa>// y se utiliza un script de envío que debe tener como mínimo lo siguiente:

<code>
#SBATCH --partition=gpu
#SBATCH --nodes=X                 # X=1 Cantidad de nodos
#SBATCH --gres=gpu:m10:Y          # Y=1,2,3,4 Cantidad de GPUs solicitadas
#SBATCH --task-per-node=(X.Y)/X   # Procesos por nodo
#SBATCH --out=slurm-%A-%a.out     # salida STDOUT
#SBATCH --error=slurm-%A-%a.err   # salida STDERR

module load CUDA/10.2
</code>

Algunas cuestiones importantes a señalar son las siguientes:

- Si no se especifica la partición //gpu//, el envío del script da error porque va a la partición por defecto //public//.

- La directiva <nowiki>--</nowiki>gres=gpu:m10:X señala el Recurso Genérico //gpu// y que se va a usar X CPUs de la tarjeta Tesla M10. Generalmente se usa X=1.

- Se especifica el módulo de CUDA/10.2, que es el instalado actualmente.

- Es importante indicar las directivas de <nowiki>--</nowiki>out= y <nowiki>--</nowiki>err para ver errores e informaciones importantes en la ejecución de la tarea que luego puedan ser usadas para la modificación de la misma, etc.

Para el caso más sencillo de trabajo con una sola GPU se utiliza el siguiente script de Slurm:

<code>
#SBATCH --partition=gpu
#SBATCH --nodes=1                   # 1 nodo
#SBATCH --gres=gpu:m10:1            # 1 GPU
#SBATCH --task-per-node=1           # 1 Proceso por nodo
#SBATCH --out=slurm-%A-%a.out       # salida STDOUT
#SBATCH --error=slurm-%A-%a.err     # salida STDER
module load CUDA/10.2
</code>

Nota importante: Hay otras especificaciones del script de envío que se verán a continuación en los casos correspondientes.

  * [[hpc-script-autodockgpu|AutoDock-GPU]]
  * [[hpc-gpu-cuda|Cálculos con CUDA usando GPU]]
  * [[hpc-gpu-python|Cálculos con Python usando GPU]]
  * [[hpc-gpu-deeplearning|Cálculos de Deep Learning]]
  * [[hpc-gpu-memcompartida|Cálculos con GPU en Memoria Compartida]]
  * [[hpc-gpu-pytorch|PyTorch con GPU]]
  * [[hpc-gpu-tensorflow)|Tensorflow/Keras]]
  * [[hpc-gpu-vc|Visión por computadora con GPU]]