Entendiendo el Sistema de Colas de Kabré

Colas Disponibles en Kabré

Los nodos de inicio de sesión son adecuados para tareas ligeras, como se mencionó anteriormente: editar archivos, compilar, copiar archivos, etc. Se espera que las tareas pesadas se ejecuten en los nodos Nukwa, Kurá o Dribe. Para hacer cumplir un reparto justo de recursos entre los usuarios, su tarea debe enviarse a un sistema de cola. Es como formarse en el banco, una vez que su tarea llega al principio de la fila, se le otorgarán todos los recursos solicitados y se ejecutará hasta que se complete o hasta que consuma su franja de tiempo.

Actualmente, hay diferentes colas para cada componente en Kabré, eso significa que no puede mezclar nodos Nukwa y nodos Kurá en un solo trabajo, por ejemplo. La siguiente tabla muestra todas las colas disponibles:

Partición (Cola)	Plataforma	Número de nodos	Asignación de tiempo
nukwa	GPU	1	24 horas
nukwa-debug	GPU	1	4 horas
nukwa-v100	GPU	1	4 horas
nukwa-l40s	GPU	1	4 horas
nukwa-wide	GPU	5	24 horas
nukwa-long	GPU	1	48 horas
dribe	Xeon	1	72 horas
dribe-long	Xeon	1	744 horas
dribe-debug	Xeon	1	8 horas
kurá	Xeon	1	72 horas
kurá-debug	Xeon	1	8 horas
kurá-wide	Xeon	4	24 horas
kurá-long	Xeon	1	168 horas

El proceso de envío de un trabajo en Kabré se puede dividir en cuatro pasos: escribir un archivo SLURM, poner su trabajo en cola, monitorear los trabajos y recuperar los resultados.

Escribiendo un archivo SLURM

Este archivo de configuración le dice al sistema de colas todo lo que necesita saber sobre su trabajo, para que pueda colocarse en la cola correcta y ejecutarse. Vamos a probarlo con un ejemplo de trabajo mínimo. A continuación se muestra un código C que se aproxima al valor de pi utilizando un método de Montecarlo. Inicie sesión en Kabré, copie el texto en un archivo y guárdelo con el nombre pi_threads.c.

#include <pthread.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>

typedef struct {
    int num_of_points;
    int partial_result;
} pi_params;

void * calc_partial_pi(void * p){
    pi_params * params = p;
    int count = 0;
    double r1, r2;
    unsigned int seed = time(NULL);

for(int i = 0; i < params->num_of_points; ++i){
    r1 = (double)rand_r(&seed)/RAND_MAX;
    r2 = (double)rand_r(&seed)/RAND_MAX;
    if(hypot(r1, r2) < 1)
    count++;
}
    params->partial_result = count;
    pthread_exit(NULL);
}

int main(int argc, char * argv[]){

if(argc != 3){
    printf("Usage: $ %s num_thread num_points
", argv[0]);
    exit(0);
}

int num_threads = atoi(argv[1]);
int num_points = atoi(argv[2]);
int num_points_per_thread = num_points / num_threads;

pthread_t threads[num_threads];
pi_params parameters[num_threads];

for(int i = 0; i < num_threads; i++){
    parameters[i].num_of_points = num_points_per_thread;
    pthread_create(threads+i, NULL, calc_partial_pi, parameters+i);
}

for(int i = 0; i < num_threads; i++)
    pthread_join(threads[i], NULL);

double approx_pi = 0;
    for(int i = 0; i < num_threads; i++)
    approx_pi += parameters[i].partial_result;
    approx_pi /= (num_threads * num_points_per_thread) / 4;

printf("Result is %f, error %f
", approx_pi, fabs(M_PI-approx_pi));

}

Actualmente, se encuentra en un nodo de inicio de sesión, por lo que está bien compilar el código allí, hágalo escribiendo:

$ gcc -std=gnu99 pi_threads.c -lm -lpthread -o pi_threads

El siguiente es un archivo SLURM de ejemplo. Todas las líneas que comienzan con #SBATCH son comandos de configuración para el sistema de colas. Las opciones que se muestran aquí son las más comunes y posiblemente las únicas que necesitará.

Configuración	Descripción
–job-name=	Nombre específico del trabajo
–output=	El nombre con el que sale el trabajo
–partition=<partición>	En qué cola debería ejecutarse
–ntasks=<número>	Número de procesos a ejecutar
–time=HH:MM:SS	Duración aproximada del trabajo

El cuerpo de un archivo SLURM es un código bash. Copie el ejemplo en un archivo llamado pi_threads.slurm

#!/bin/bash
#SBATCH --job-name=pi_threads
#SBATCH --output=result.txt
#SBATCH --partition=kura
#SBATCH --ntasks=1
#SBATCH --time=00:10:00

module load gcc/7.2.0

srun ./pi_threads 64 100000000000

Nota: Los argumentos de la línea de comando 64 y 100000000000 son los parámetros específicos necesarios para ejecutar pi threads.

Ahora, desde la línea de comando, invoque al remitente de colas:

$ sbatch pi_threads.slurm

¡Y eso es todo! Su trabajo se pondrá en cola y se ejecutará.

Monitoreando sus trabajos activos

Una forma pasiva de monitorear sus trabajos es indicarle a SLURM que envíe un correo electrónico cuando haya terminado. Esto se puede configurar en el archivo SLURM usando las siguientes opciones:

Configuración	Descripción
–mail-user=	Dónde enviar alertas de correo
–mail-type=<BEGIN|END|FAIL|REQUEUE|ALL>	Cuándo enviar alertas de correo

#SBATCH --mail-user=example@mail.com
#SBATCH --mail-type=END,FAIL

Una forma pasiva de monitorear sus trabajos es indicarle a SLURM que envíe un correo electrónico cuando haya terminado. Esto se puede configurar en el archivo SLURM usando las siguientes opciones:

Configuración	Descripción
squeue -u	Verificar trabajos para un usuario específico
sinfo	Mostrar todos los nodos (con atributo)
scontrol show job <job_id>	Estado de un trabajo en particular
scancel <job_id>	Eliminar trabajo

Para mostrar detalles sobre el estado de un trabajo:

$ squeue -j <jobid>

Para mostrar detalles sobre el estado de un trabajo:

$ watch -n <num_seconds> squeue -j <jobid>

Estados de trabajo válido

Para comprender los códigos de estado de trabajo que puede encontrar, verifique lo siguiente:

Código	Estado
CA	Cancelado
CD	Completado
CF	Configurando
CG	Completando
F	Fallo
NF	Fallo de nodo
PD	Pendiente
R	Corriendo
TO	Timeout
S	Suspendido

Recuperando resultados

De forma predeterminada, cada trabajo generará un archivo de salida con un nombre como en el siguiente ejemplo:

$ result.txt

Puede copiar este archivo a su computadora local o ejecutar otro script para procesar posteriormente la salida.

Trabajos interactivos

A veces desea tener acceso directo a algún nodo. Usar ssh directamente es una mala práctica, porque el sistema de cola podría enviar el trabajo de otra persona para que se ejecute en el nodo que está utilizando actualmente. La forma educada de solicitar acceso directo es a través de un trabajo interactivo que lo pondrá en una ventana interactiva en un nodo de cómputo. Esto le permite experimentar con diferentes opciones y variables que proporcionarán retroalimentación inmediata.

Para solicitar una cola interactiva puede utilizar:

$ salloc

Esto lo llevará a uno de los nodos Nu de forma predeterminada, pero para elegir otras colas puede usar el parámetro -p, de la siguiente forma:

$ salloc --partition=[Partition]

Lo anterior le brindará una ventana a uno de los nodos de la cola que usted elija, ya sea: dribe, kura o nukwa; así como a sus variables: kura-wide, kura-long, kura-debug, etc.