Información y ayuda

HPC Universidad de Oriente

Herramientas de usuario

Herramientas del sitio


hpc-guia

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 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.

Conectándose al HPC UO

Los usuarios que utilizan el sistema operativo (SO) GNU/Linux pueden conectarse al HPC UO mediante el comando ssh desde una ventana texto:

$ ssh <nombre_usuario>@login.uo.hpc.cu 

Por su parte, los usuarios con SO Windows pueden acceder usando MobaXterm o Putty, insertando su <nombre_usuario> al conectarse a login.uo.hpc.cu.

Para desconectarse, se usa el comando exit.

Igualmente, los usuarios pueden conectarse vía web a través del Portal Web del HPC UO.

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 (/home/CLUSTER/nombre_usuario) usando el 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 winscp o MobaXterm.

Cambio de contraseña

Los usuarios pueden cambiar su contraseña a través de su Perfil de usuario en el 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ústerNodosCores/nodoRAM/nodo(GB)TFLOPS totalesConexión
HPC UO 1432644.5Infiniband 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 /home/CLUSTER/nombre_usuario (se referencia con la variable de entorno $HOME de Linux) y el directorio /scratch.

DirectorioLocalizaciónRespaldoEspacio
$HOMEred (NFS)Si10 GB cuota
/scratchred (NFS)No10 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:

$ module available 

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

$ module load Python 

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

Para cargar una versión específica:

$ module load Python/2.1 

Es posible listar los módulos cargados con:

$ module list 

Otros comandos útiles son:

$ module unload <module> -> desactiva un módulo previamente cargado. 
$ module purge           -> desactiva todos los módulos cargados. 
$ module whatis <module> -> muestra descripción del módulo. 
$ module show <module>   -> muestra el contenido del módulo. 

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

$ module help 

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 (Simple Linux Utility for Resource Manager), 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.

#!/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

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:

#!/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

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 --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 --time= con un valor estimado por el usuario. Si no se especifica el tiempo con #SBATCH --time=, se toma el tiempo máximo definido para la partición.

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

ColaTiempo MáximoMax. Trabajos en ejecuciónMax. Trabajos enviadosRecursos
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 --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 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 comandos que permiten el envío y monitoreo de los trabajos, la modificación de los recursos solicitados, entre otros.

ComandoFunción
sbatch [job_script]Envío de trabajo
squeueEstado del trabajo/cola
scancel [job_id]Borrar trabajo
scontrol show nodesMostrar 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
sallocAsignar nodos
srunLanzar un paso de un trabajo (paralelo)
sacctMuestra 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:

$ sbatch miscript.sl

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 --ntasks=1, el usuario puede especificar 4 tareas totales usando la línea de comando:

$ sbatch --ntasks=4 miscript.sl

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

sinfo

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

$ 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

La información anterior significa que la partición public tiene 13 nodos (nodo001, nodo002nodo013), 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 --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.

$ 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

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:

$ 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

Para ver la información de los trabajos:

$ scontrol show job 115

scancel

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

$ scancel job 115

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:

$ srun -n 16 hostname

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:

VariableSignificado
SLURM_JOBIDID 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

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:

ArquitectureMaxwell
GPUs per board4 (GPU 0,1,2,3)
Cores2560 (640 por GPU)
GPU Memory32GB (8 por GPU)
Core clock1.03 GHz
Compute capability5
CUDA driver version: 10.210.2
Streaming Multiprocessors (SM)5
Threads per SM2024
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 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:

#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

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 --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 --out= y --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:

#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

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

hpc-guia.txt · Última modificación: 2023/02/08 16:31 por Beatriz Valdés Díaz