Parque Computacional de Alto Desempenho (PCAD)

O PCAD possui mais de 1.000 núcleos de CPU e 100.000 de GPU (CUDA threads), distribuídos em 40 nós computacionais. Pode-se compreender um nó como sendo um conjunto de processamento com configurações específicas. Por exemplo, cada nó possui uma determinada quantidade de um processador específico, uma quantidade específica de memória RAM por processador, uma GPU específica, agrupados no que chamamos de rack. Desse modo, temos diferentes nós de computação que apresentam diferentes características e configurações. O usuário pode escolher entre os diversos nós de acordo com sua necessidade específica. Por exemplo, para executar uma aplicação de IA, o usuário escolheria o nó hype, devido à presença de uma GPU NVIDIA Tesla K80, enquanto que para uma aplicação que execute exclusivamente em CPU, pode-se fazer uso de um nó sem GPU.

Já partições representam a forma como esses nós estão organizados. Como pode-se ter mais de um nó com as mesmas características, dizemos que os nós que possuem as mesmas características fazem parte de uma partição. Como exemplo temos os 7 nós draco, que são 7 máquinas com as mesmas características agrupados sob a partição draco.

Os nós existentes no PCAD são detalhados a seguir:

• * Partições com máquinas de projetos que requerem permissão do coordenador do projeto

Os arquivos de cada usuário estão armazenados no front-end e são acessados pelos nós de computação através de Network File System (NFS). De maneira transparente, o NFS monta os dados do usuário na partição que foi alocada e o usuário acessa os dados como se eles estivessem armazenados localmente. Assim, o /home de cada usuário é acessível a partir de cada nó de computação.

Usuários podem executar aplicações que leem e escrevem dados diretamente na sua /home física, ou seja, no front-end. No entanto, essas operações serão feitas pela rede, o que as torna lentas. O ideal, portanto, é utilizar o scratch, que está localizado no o disco local fisicamente ligado ao nó computacional.

O scratch é um diretório temporário presente em cada nó de computação e montado no sistema de arquivos próprio do nó. Cada usuário possui um diretório dentro do scratch (/scratch/USERNAME). A variável de ambiente $SCRATCH é configurada automaticamente no momento do login. Desse modo, para acessar seu diretório scratch, basta acessar $SCRATCH:

cd $SCRATCH

Antes da execução da aplicação, o usuário pode copiar os dados do seu /home no NFS para o seu scratch, acessando as variáveis $HOME e $SCRATCH:

cp $HOME/<diretório_origem> $SCRATCH/<diretório_destino>

No entanto, os dados são mantidos temporariamente no scratch do nó e não podem ser acessados diretamente por outros nós de computação. Desse modo, o usuário precisa copiar os dados para o seu home ao final da execução do job:

cp $SCRATCH/<diretório_origem> $HOME/<diretório_destino>

IMPORTANTE: os arquivos presentes no scratch são temporários e podem ser removidos a qualquer momento sem aviso prévio aos usuários. Por isso se sugere que, assim que um job termine sua execução, os dados relevantes sejam transferidos para a área de armazenamento do /home.

SUPER IMPORTANTE: os dados na home e no scratch não possuem backup sendo o usuário o responsável por manter seus backups. Usuários podem copiar seus arquivos de e para o PCAD usando o "scp" do ssh.

Da máquina pessoal para o PCAD (a partir da máquina pessoal):

scp <diretório_origem> <usuario_no_pcad>@gppd-hpc.inf.ufrgs.br:~/<diretório_destino>

Do PCAD para a máquina pessoal (a partir do PCAD):

scp <diretório_origem> <usuario_na_sua_maquina>@<maquina_pessoal>:~/<diretório_destino>

Para submeter jobs interativos, é necessário utilizar o comando salloc, solicitando os recursos a serem utilizados. Quando o salloc consegue alocar os recursos solicitados para o job, ele informa ao usuário, o qual pode acessar o nó (via ssh), realizar as suas tarefas localmente e executar a aplicação.

• Exemplo 1

Solicita a alocação de qualquer nó da partição draco por 5h.

salloc -p draco -J NOME-JOB-EX1 -t 05:00:00

• Exemplo 2

Solicita a alocação da draco6 por 36h.

salloc -p draco -w draco6 -J NOME-JOB-EX2 -t 36:00:00

• Exemplo 3

Solicita a alocação de dois nós da partição hype por 24h.

salloc -p hype -N 2 -J NOME-JOB-EX3 -t 24:00:00

• Exemplo 4

Solicita a alocação de 6 núcleos da partição shared por 1h. O uso do nó é compartilhado com outros usuários, entretanto, os núcleos solicitados são dedicados.

salloc -p shared -c 6 -J NOME-JOB-EX4 -t 1:00:00

Jobs não interativos são aqueles onde o usuário submete um script que realiza o experimento nas máquinas. O slurm permite esse tipo de script utilizando diretivas em linhas que começam com #SBATCH. Todas as linhas que começam com esta diretiva terão seu conteúdo passado diretamente para o slurm no momento da alocação. O exemplo 1 abaixo aloca um nó (--nodes=1) para 16 tarefas (--ntasks=16) na partição draco (--partition=draco) por 2 horas (--time=02:00:00). Recomenda-se o uso de parâmetros --output e --error de forma que a saída padrão e de erro sejam direcionadas para arquivos, permitindo o debug do job. No caso de exemplo, esses arquivos serão o nome do job (%x, no caso o nome do arquivo que contém o script) e o seu ID (%j). As linhas que não contém a diretiva do sbatch serão executadas normalmente.

• Exemplo 1

No exemplo abaixo, o comando hostname é executado.

#!/bin/bash
#SBATCH --job-name=exemplo1
#SBATCH --partition=draco
#SBATCH --nodes=1
#SBATCH --ntasks=16
#SBATCH --time=02:00:00
#SBATCH --output=%x_%j.out
#SBATCH --error=%x_%j.err

hostname

Assumindo que o conteúdo acima está em um arquivo draco.slurm, basta submeter o job da seguinte maneira na portal:

sbatch draco.slurm

• Exemplo 2

No exemplo abaixo, um aplicação é executada em 7 nós da partição draco.

#!/bin/bash
#SBATCH --job-name=exemplo2
#SBATCH --partition=draco
#SBATCH --nodes=7
#SBATCH --ntasks=224
#SBATCH --time=6:00:00
#SBATCH --output=%x_%j.out
#SBATCH --error=%x_%j.err

mpicc exemplo2.c

MACHINEFILE="nodes.$SLURM_JOB_ID"
srun -l hostname | sort -n | awk '{print $2}' > $MACHINEFILE

mpirun --mca btl ^openib --mca btl_tcp_if_include eno1 --bind-to none -np $SLURM_NTASKS -machinefile $MACHINEFILE ./a.out

Assumindo que o conteúdo acima está em um arquivo draco_multi.slurm, basta submeter o job da seguinte maneira na portal:

sbatch draco_multi.slurm

• Exemplo 3

No exemplo abaixo, um aplicação é executada em 2 nós da partição hype.

#!/bin/bash
#SBATCH --job-name=exemplo3
#SBATCH --partition=hype
#SBATCH --nodes=2
#SBATCH --ntasks=80
#SBATCH --time=2:00:00
#SBATCH --output=%x_%j.out
#SBATCH --error=%x_%j.err

mpicc exemplo3.c

MACHINEFILE="nodes.$SLURM_JOB_ID"
srun -l hostname | sort -n | awk '{print $2}' > $MACHINEFILE

mpirun --mca oob_tcp_if_include 192.168.30.0/24 --mca btl_tcp_if_include 192.168.30.0/24 --mca btl_base_warn_component_unused 0 --bind-to none -np $SLURM_NTASKS -machinefile $MACHINEFILE ./a.out

Assumindo que o conteúdo acima está em um arquivo hype.slurm, basta submeter o job da seguinte maneira na portal:

sbatch hype.slurm

Uma forma muito frequente de uso de um cluster de computadores é o emprego de múltiplas máquinas (nós) para executar a mesma aplicação com emprego de MPI. Assumindo um programa MPI simples do tipo "Olá Mundo" com o seguinte conteúdo no arquivo olamundo.c:

#include <mpi.h>
#include <stdio.h>
#include <unistd.h>
int main(int argc, char **argv)
{
  int rank;
  char hostname[256];
  MPI_Init(&argc,&argv);
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  gethostname(hostname,255);
  printf("Olá Mundo!  Eu sou [%d] executando em [%s].\n", rank, hostname);
  MPI_Finalize();
  return 0;
}

Compile-o com mpicc:

mpicc olamundo.c -o olamundo

Construa um script slurm chamado multi-no.slurm com o conteúdo abaixo. Serão alocados 5 nós com 80 tarefas na partição draco por 2 horas. O primeiro comando srun criará um arquivo de máquinas para a execução do programa MPI. Cada linha desta arquivo conterá o nome do nó onde será executada a aplicação MPI; como existem múltiplos cores, o nome do nó será repetido várias vezes.

#!/bin/bash
#SBATCH --job-name=exemplo
#SBATCH --partition=draco
#SBATCH --nodes=5
#SBATCH --ntasks=80
#SBATCH --time=2:00:00
#SBATCH --output=%x_%j.out
#SBATCH --error=%x_%j.err

MACHINEFILE="nodes.$SLURM_JOB_ID"
srun -l hostname | sort -n | awk '{print $2}' > $MACHINEFILE

mpirun -np $SLURM_NTASKS \
       -machinefile $MACHINEFILE \
       --mca btl ^openib \
       --mca btl_tcp_if_include eno2 \
       --bind-to none -np $SLURM_NTASKS \
       ./olamundo

Assumindo que o programa olamundo foi compilado na $HOME do usuário e que o script abaixo se encontra no mesmo local, basta submeter o job da maneira habitual:

sbatch multi-no.slurm

O slurm permite a criação de jobs multi-partição, para o caso onde o usuário deseja usar nós heterogêneos de partições diferentes. A documentação do slurm sobre jobs heterogêneos apresenta um detalhamento bastante rico sobre o assunto. Abaixo apresentamos um exemplo simples para a aplicação do tipo "Olá Mundo!", compilada no binário olamundo.

Crie um arquivo multi-particao.slurm com o conteúdo abaixo. Solicitaremos nós de três partições (5 nós da hype, cada um com 20 tarefas; 5 nós da draco, cada um com 16 tarefas, e o único nó da partição turing, com 32 tarefas). A diretiva packjob deve ser obrigatoriamente empregada para separar os comandos de alocação para cada partição. Como o programa MPI precisa de um arquivo de máquinas de todo o conjunto, incluímos a função shell gen_machinefile que imprime as nós alocados de uma partição de acordo com a quantidade de tarefas alocadas naquele nó. Essa função é chamada para cada uma das partições que foram alocadas, e toda a saída é direcionada para o arquivo de máquinas (variável MACHINEFILE)

#SBATCH --time=02:00:00
#SBATCH --output=%x_%j.out
#SBATCH --error=%x_%j.err
#SBATCH --nodes=5 --partition=hype --ntasks=20
#SBATCH packjob
#SBATCH --nodes=5 --partition=draco --ntasks=16
#SBATCH packjob
#SBATCH --nodes=1 --partition=turing --ntasks=32

# Função para gerar um arquivo de máquina para uma partição
function gen_machinefile {
        SLM_NODES=$1
        SLM_TASKS=$2

        if [ -z "$SLM_NODES" ]; then
                return
        fi

        for host in $(scontrol show hostname $SLM_NODES); do
                for machine in $(seq 1 $SLM_TASKS); do
                        echo $host
                done
        done
}
# Três partições foram alocadas, portanto três chamadas a gen_machinefile
MACHINEFILE="nodes.$SLURM_JOB_ID"
gen_machinefile $SLURM_JOB_NODELIST_PACK_GROUP_0 $SLURM_NPROCS_PACK_GROUP_0 > $MACHINEFILE
gen_machinefile $SLURM_JOB_NODELIST_PACK_GROUP_1 $SLURM_NPROCS_PACK_GROUP_1 >> $MACHINEFILE
gen_machinefile $SLURM_JOB_NODELIST_PACK_GROUP_2 $SLURM_NPROCS_PACK_GROUP_2 >> $MACHINEFILE

# Definir a quantidade de máquinas baseado no arquivo
SLM_NTASKS=$(wc -l $MACHINEFILE | awk '{ print $1 }')

# Executar a aplicação
mpirun -np $SLM_NTASKS \
       -machinefile $MACHINEFILE \
       --mca oob_tcp_if_include 192.168.30.0/24 \
       --mca btl_tcp_if_include 192.168.30.0/24 \
       --mca btl_base_warn_component_unused 0 \
       --bind-to none \
       ./olamundo

Pelo número do job

scancel NUMERO-DO-JOB

Todos jobs do usuário

scancel -u NOME-DO-USUARIO

A frequência e governor podem ser alterados por qualquer usuário utilizando o comando cpu-freq.

O turbobost pode ser alterado editando diretamente o arquivo: /sys/devices/system/cpu/cpufreq/boost.

O Numa balancing pode ser ativado ou desativado utilizando os comandos (com sudo):

sudo /sbin/sysctl kernel.numa_balancing=1
sudo /sbin/sysctl kernel.numa_balancing=0

A frequência da GPU (MEM, GRAPHICS) pode ser configurada utilizando o comando:

gpu_control 715 1480

Esta é a saída do comando acima na máquina blaise.

Executing command [nvidia-smi -ac 715,1480]
Applications clocks set to "(MEM 715, SM 1480)" for GPU 00000000:05:00.0
Applications clocks set to "(MEM 715, SM 1480)" for GPU 00000000:06:00.0
Applications clocks set to "(MEM 715, SM 1480)" for GPU 00000000:84:00.0
Applications clocks set to "(MEM 715, SM 1480)" for GPU 00000000:85:00.0
All done.