Dell AMD EPYC 7662 / NVIDIA Tesla A100

Execução de jobs

Para executar suas aplicações no ambiente Lovelace os usuários devem submeter jobs para o sistema de filas.

Neste ambiente estão disponíveis as seguintes máquinas:

Software gerenciador do sistema de filas

O sistema de filas é gerenciado por meio do software OpenPBS respeitando as políticas estabelecidas. No OpenPBS usamos o conceito de filas, que são formas de classificação das tarefas a serem processadas nos nós computacionais utilizando critérios como, por exemplo, o número de processadores e a quantidade de nós requisitados, a quantidade de memória RAM e o tempo de processamento necessários para execução da aplicação.

A submissão de jobs para execução pode ser feita de várias formas, entre elas destacamos:

Submissão por shell script

A forma mais simples de submeter um job para execução é por meio de um script, ou seja, um arquivo que contém os comandos a serem executados e as diretivas que descrevem os requisitos necessários para a execução do job.

As diretivas são interpretadas pelo PBS (software de gerenciamento de filas) e são identificadas pelas linhas iniciadas com os caracteres #PBS.

IMPORTANTE: O PBS considera todas as diretivas em ordem de posicionamento, até que encontre um comando executável. As diretivas especificadas após este comando executável são ignoradas.

Principais diretivas em um script PBS
#PBS -N nome_do_job Nome para identificação do job
#PBS -q fila Nome da fila de processamento, na qual o job será processado
#PBS -l nodes=número_de_nós:ppn=número_de_processos_por_nó Informações para seleção de recursos que serão utilizados pelo programa na execução paralela do programa. Esta diretiva NÃO deve ser usada nas filas umagpu, duasgpus, miggpu e testegpu pois o numero de nós/cpus é configurado automaticamente para 8 (miggpu, testegpu), 16 (umagpu) ou 32 (duasgpus) nessas filas
#PBS -m abe Indica que deve ser enviado um email quando o job for cancelado a(abort), iniciado b(begin) e finalizado e(end). O email será enviado para o endereço do usuário cadastrado no CENAPAD-SP
#PBS -e nome_erros Nome arquivo onde serão gravadas as mensagens de stderr
#PBS -o nome_resultados Nome arquivo onde serão gravadas as mensagens de stdout

Configuração de variáveis de ambiente necessárias para execução do job

O shell script deve conter também comandos para definição das variáveis de ambiente e carregamento dos modulefiles necessários para execução do job.

Variáveis de ambiente importantes
export OMP_NUM_THREADS=n Indica o número de threads que serão utilizadas por um programa multithread. No ambiente lovelace, esse parâmetro está definido, por padrão, como OMP_NUM_THREADS=1 (ou seja, sem uso de threads paralelas)
module load modulefiles Indica o(s) modulefile(s) que deve(m) ser carregado(s) para configurar a execução dos programas usados no job

Execução de comandos

O shell script deve conter também os comandos necessários para execução do job.

Exemplos de comandos
nome_do_programa parâmetros_do_programa Para execução de programas paralelos multithread ou de programas seriais: o nome do executável
mpirun -np número_de_processos nome_do_programa parâmetros_do_programa Para execução de programas paralelos multitask (multi processos): o comando "mpirun" em conjunto com o nome do executável, para iniciar os processo paralelos

Submissão de programas nas filas

Após a criação de um script PBS, é necessário submetê-lo para execução. Isto é feito através de comando para o gerenciador de filas e resulta em um job.

qsub nome_do_script_PBS

A execução deste comando retorna um código de identificação do job (id do job) na fila.

Exemplo:

             qsub meuteste
             id_do_job.ada

Verificar a situação do job

É possível verificar a situação de todos os jobs em todas as filas e/ou especificamente os jobs do seu usuário:

Comando Descrição
qstat exibe todos os jobs nas filas
qstat -u usuário exibe apenas os jobs do usuário indicado
qstat -f id_do_job exibe detalhes do job aguardando recursos ou em execução

Os jobs podem apresentar os seguintes status:

Status Descrição
Q Queued: job está na fila aguardando recursos para executar
R Running: job está executando
H Holding: job está suspenso na fila e não será selecionado para execução, por determinação do sistema ou do próprio usuário

Suspender um job

Mantém o job na fila, indicando que não deverá ser selecionado para execução.

qhold id_do_job

Liberar um job suspenso

Libera um job suspenso, que passa a ser selecionado para execução

qrls id_do_job

Cancelar um job

Retira o job da fila ou cancela a execução.

qdel id_do_job

Voltar ao topo

Filas e Limites

O ambiente de processamento de jobs está dividido nos seguintes grupos:

Cada um dos referidos grupos possui filas configuradas para:

Tais filas diferenciam-se por:

Limite global:

Observação: Os jobs precisam ser executados com recursos (filas, memória, processadores ou GPU) não excedendo o necessário para sua execução. Utilizar filas maiores do que o necessário ou recursos que não serão utilizados resulta em desperdício de recursos, o que pode levar ao consumo total das Unidades de Alocação (UAs) do projeto e fazer com que ele seja expirado.

Ordem de Execução dos Jobs

O escalonador PBS, implantado no ambiente Lovelace, impõe limites ao número de jobs por usuário e por projeto. Tais limites variam de acordo com a fila escolhida para a execução do job e estão condicionados à disponibilidade dos recursos necessários para o job.

O PBS utiliza o algoritmo fairshare para selecionar os próximos jobs que serão executados. O objetivo do algoritmo é distribuir proporcionalmente os recursos computacionais entre todos os usuários, priorizando os que, recentemente, utilizaram menos recursos. Isso é feito para garantir um uso equitativo do sistema.

De acordo com a política fairshare, a ordem de execução dos jobs é feita através de uma medida do uso recente de recursos pelos usuários que os submeteram. Isso significa que, se um usuário consumir uma quantidade alta de recursos recentemente, sua prioridade é temporariamente reduzida para permitir que outros usuários, que usaram menos recursos, tenham a chance de executar seus jobs. A prioridade de um usuário aumentará novamente à medida que o indicador de consumo de recursos decair. Tal indicador é reduzido pela metade a cada 24 horas). Portanto, jobs em espera devido a essa priorização tendem a ser iniciados à medida que a prioridade do usuário se restabelece ao longo dos dias.

É importante salientar que a política fairshare foca na prioridade atual dos usuários, baseada no uso recente de recursos, em vez da ordem de submissão dos jobs. A aplicação do algoritmo faz com que um job submetido por um usuário que está há algum tempo usando poucos recursos seja executado antes de jobs anteriormente submetidos, caso estes últimos pertençam a usuários que fizeram uso mais intensivo dos recursos recentemente.

Uso Eficiente de Recursos e Monitoramento

No CENAPAD-SP, a eficiência e o uso consciente dos recursos do nosso ambiente de HPC são fundamentais. Implementamos um sistema de monitoramento automatizado e proativo para assegurar a distribuição justa e a otimização do uso desses recursos. Nosso objetivo é duplo: garantir o acesso equitativo aos recursos e orientar nossos usuários na maximização da eficácia de seus jobs.

Políticas de Monitoramento e Ações Corretivas

Expectativas de Eficiência por Recurso

Definimos expectativas específicas de eficiência para cada recurso principal de HPC utilizado, inferido pela fila escolhida pelo usuário.

Além disso, possuímos filas dedicadas para necessidades específicas que não exigem o uso intensivo de recursos de HPC, como:

Para estas filas, nosso monitoramento foca em situações atípicas, como o uso reiterado da fila "testegpu" sem efetiva utilização da GPU, ou jobs nas filas "serial" e "testes" que pareçam estar travados ou operando de maneira anômala. Nestes casos, apesar de a monitoração ser menos frequente, pode ser necessária intervenção para assegurar o uso adequado dos recursos e a disponibilidade para todos os usuários.

Orientação e Suporte

Reconhecemos os desafios técnicos em otimizar o uso de recursos de HPC e estamos prontos para auxiliar. Se receber uma notificação nossa, incentivamos o contato para explorar formas de melhorar a eficiência do seu job. Nossa equipe oferece suporte técnico completo, incluindo orientações e práticas recomendadas para aproveitar ao máximo o ambiente Lovelace.

Fila Limites por Job Número Máximo de Jobs Consumo
de UAs(*) por Hora
Número
de Nós		 Número de CPUs (GPUs) Memória RAM (VRAM) Tempo Máximo de Execução Em Execução Em Execução
ou na Fila
Por Usuário Por Projeto Por Usuário Por Projeto
expressa(**) 20 2560 [128/nó] 488 GB/nó 1 dia 1 1 1 1 32 / nó
paralela 2-8 256-1024 [128/nó] 488 GB/nó 3 dias 2 6 2 6 32 / nó
parexp 3-22 144-1056 [48/nó] 128 GB/nó 1 dia 3 5 3 5 12 / nó
par16 1 16 60 GB 10 dias 4 12 8 12 4
par128 1 128 488 GB 7 dias 6 12 6 12 32
testes 1 2-4 10 GB 1 hora 2 8 2 8 0,25 / CPU
serial 1 1 2,5-10 GB(***) 10 dias 16 32 32 64 0,25
memlong 1 128 2 TB 15 dias 1 1 1 1 42
memshort 1 128 2 TB 2 dias 1 1 1 1 42
duasgpus 1 32
(2 GPUs)		 120 GB (80 GB) 3 dias 1 1 1 1 64
umagpu 1 16 (1 GPU) 60 GB (40 GB) 7 dias 2 4 2 4 32
miggpu 1 8
(1/2 GPU)		 30 GB (20 GB) 7 dias 2 2 2 3 16
miggpu24h 1 8
(1/2 GPU)		 30 GB (20 GB) 1 dia 1 1 2 3 16
testegpu 1 8
(1/2 GPU)		 30 GB (20 GB) 30 min 1 4 2 8 16
(*) UAs - Unidades de Alocação
(**) ativada apenas por solicitação para suporte@cemapad.unicamp.br
(***) default de 2,5 GB, se não especificado, e máximo de 10 GB se especificado no cabeçalho do job com "#PBS -l mem=10G"

As configurações e limites descritos acima podem ser modificados a qualquer momento, sem aviso prévio.

Voltar ao topo

Exemplos de jobs

Alguns exemplos de scripts para submissão de jobs, para cada fila de processamento:

  1. Fila serial
  2. Fila testes
  3. Fila testegpu
  4. Fila par128
  5. Fila par16
  6. Fila pararela
  7. Fila parexp
  8. Fila expressa
  9. Fila memshort
  10. Fila memlong
  11. Fila miggpu
  12. Fila miggpu24h
  13. Fila umagpu
  14. Fila duasgpus

  1. Processamento na fila serial

    A fila serial deve ser usada para o processamento de programas seriais, que não utilizam nenhum recurso de paralelização

    • Aloca apenas um core de um único nó;
    • Tempo máximo de processamento (walltime): 30 dias
    • Diretiva necessária:
      • #PBS -q serial

    Exemplo para execução de um job serial:

    #PBS -N meuteste
#PBS -q serial
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
nome_do_programa parâmetros_do_programa

  2. Processamento na fila testes

    A fila testes deve ser usada para a execução de testes de programas ou scripts de submissão.

    • Aloca de 2 a 4 cores de um único nó;
    • Tempo máximo de processamento (walltime): 33 minutos
    • Diretivas necessárias:
      • #PBS -q testes
      • #PBS -l nodes=1:ppn=de 2 até 4
    • Caso a diretiva #PBS -l não seja especificada, será selecionado 1 nó e 2 cores

    Exemplo para execução de teste multithread (SMP):

    #PBS -N meuteste
#PBS -q testes
#PBS -l nodes=1:ppn=2
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=2
nome_do_programa parâmetros_do_programa

    Exemplo para execução de teste multitask (MPI):

    #PBS -N meuteste
#PBS -q testes
#PBS -l nodes=1:ppn=4
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
mpirun -np 4 nome_do_programa parâmetros_do_programa

    Exemplo para execução de teste híbrido (Multithread + Multitask):

    #PBS -N meuteste
#PBS -q testes
#PBS -l nodes=1:ppn=4
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=2
mpirun -np 4 nome_do_programa parâmetros_do_programa

  3. Processamento na fila testegpu

    A fila testegpu deve ser usada para a execução de testes de programas ou scripts de submissão que requerem o uso de recursos de GPUs.

    • Aloca 8 cores em um único nó, 30G de RAM e uma MIG (Multi Instance GPU) com metade dos recursos de processamento e memória de uma GPU Nvidia A100 40GB;
    • Tempo máximo de processamento (walltime): 30 minutos
    • Diretivas necessárias:
      • #PBS -q testegpu

    Exemplo para execução teste Multitask+GPU

    #PBS -N meuteste
#PBS -q testegpu
#PBS -e erros
#PBS -o saida

# Caso seu software nao detecte a MIG como uma GPU, descomente a linha abaixo

unset CUDA_VISIBLE_DEVICES

cd $PBS_O_WORKDIR

module load modulefile
mpirun -np 8 nome_do_programa

    Exemplo para execução teste Multithread+GPU

    #PBS -N meuteste
#PBS -q testegpu
#PBS -e erros
#PBS -o saida

# Caso seu software nao detecte a MIG como uma GPU, descomente a linha abaixo

unset CUDA_VISIBLE_DEVICES

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=8
nome_do_programa

  4. Processamento na fila par128

    Fila para execução de programas que utilizam recursos de paralelização multithread (SMP), multitask (MPI) e híbrida, multitask+multithread (MPI+SMP)

    • Aloca um nó exclusivo (128 cores);
    • Tempo máximo de processamento (walltime): 7 dias
    • Diretivas necessárias:
      • #PBS -q par128
      • #PBS -l nodes=1:ppn=128

    Exemplo para execução multithread (SMP)

    #PBS -N meuteste
#PBS -q par128
#PBS -l nodes=1:ppn=128
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=128
nome_do_programa

    Exemplo para execução multitask (MPI)

    #PBS -N meuteste
#PBS -q par128
#PBS -l nodes=1:ppn=128
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
mpirun -np 128 nome_do_programa

    Exemplo para execução híbrida (Multithread + Multitask)

    Neste exemplo, serão iniciados 64 processos e cada processo irá executar com 2 threads, num total de 128 threads, cada thread em um core do nó.

    #PBS -N meuteste
#PBS -q par128
#PBS -l nodes=1:ppn=128
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=2
mpirun -np 64 nome_do_programa

  5. Processamento na fila par16

    A fila par16 deve ser usada para a execução de testes de programas ou scripts de submissão.

    • Aloca de 16 cores de um único nó;
    • Tempo máximo de processamento (walltime): 10 dias
    • Diretivas necessárias:
      • #PBS -q par16
      • #PBS -l nodes=1:ppn=16
    • Caso a diretiva #PBS -l não seja especificada, será selecionado 1 nó e 16 cores

    Exemplo para execução de teste multithread (SMP):

    #PBS -N meuteste
#PBS -q par16
#PBS -l nodes=1:ppn=16
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=16
nome_do_programa parâmetros_do_programa

    Exemplo para execução de teste multitask (MPI):

    #PBS -N meuteste
#PBS -q par16
#PBS -l nodes=1:ppn=16
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
mpirun -np 16 nome_do_programa parâmetros_do_programa

    Exemplo para execução de teste híbrido (Multithread + Multitask):

    #PBS -N meuteste
#PBS -q par16
#PBS -l nodes=1:ppn=16
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=2
mpirun -np 8 nome_do_programa parâmetros_do_programa

  6. Processamento na fila paralela

    A fila paralela deve ser usada para execução de programas que utilizam recursos de paralelização multitask (MPI) e híbrida multitask+multithread (MPI+SMP).

    • Alocação entre 2 e 8 nós exclusivos, e 128 cores por nó
    • Tempo máximo de processamento (walltime): 5 dias
    • Diretivas necessárias:
      • #PBS -q paralela
      • #PBS -l nodes=de 2 até 8:ppn=128
      • OBS: o parâmetro ppn=128, que indica o número de processadores por nó, é fixo e não deve ser alterado. Desta forma, será possível executar a partir de 256 processos (nodes=2:ppn=128) até 1024 processos (nodes=8:ppn=128)

    Exemplo para execução multitask (MPI)

    #PBS -N meuteste
#PBS -q paralela
#PBS -l nodes=4:ppn=128
#PBS -m abe
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
mpirun -np 512 nome_do_programa

    Exemplo para execução híbrida (Multithread + Multitask)

    Neste exemplo, serão iniciados o total de 512 processos, 64 processos por nó, e cada processo irá executar com 2 threads, totalizando 1024 threads, cada thread executando em um core de cada nó.

    #PBS -N meuteste
#PBS -q paralela
#PBS -l nodes=8:ppn=128
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=2
mpirun -np 512 -ppn 64  nome_do_programa

  7. Processamento na fila parexp

    A fila parexp deve ser usada para execução de programas que utilizam recursos de paralelização multitask (MPI) e híbrida multitask+multithread (MPI+SMP).

    • Alocação entre 3 e 22 nós exclusivos, e 48 cores por nó
    • Tempo máximo de processamento (walltime): 1 dia
    • Diretivas necessárias:
      • #PBS -q parexp
      • #PBS -l nodes=de 3 até 22:ppn=48
      • OBS: o parâmetro ppn=48, que indica o número de processadores por nó, é fixo e não deve ser alterado. Desta forma, será possível executar a partir de 144 processos (nodes=3:ppn=144) até 1056 processos (nodes=22:ppn=48)

    Exemplo para execução multitask (MPI)

    #PBS -N meuteste
#PBS -q parexp
#PBS -l nodes=3:ppn=48
#PBS -m abe
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
mpirun -np 144 nome_do_programa

    Exemplo para execução híbrida (Multithread + Multitask)

    Neste exemplo, serão iniciados o total de 192 processos, 24 processos por nó, e cada processo irá executar com 2 threads, totalizando 192 threads, cada thread executando em um core de cada nó.

    #PBS -N meuteste
#PBS -q parexp
#PBS -l nodes=4:ppn=48
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=2
mpirun -np 96 -ppn 24  nome_do_programa

  8. Processamento na fila expressa

    Fila para execução de programas que utilizam recursos de paralelização multitask (MPI) e híbrida, multitask+multithread (MPI+SMP)

    • Utilização de 20 nós exclusivos e 128 cores por nó;
    • Tempo máximo de processamento (walltime): 24 horas
    • Diretivas necessárias:
      • #PBS -q expressa
      • #PBS -l nodes=20:ppn=128

    Exemplo para execução multitask (MPI)

    #PBS -N meuteste
#PBS -q expressa
#PBS -l nodes=20:ppn=128
#PBS -m abe
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
mpirun -np 2560 nome_do_programa

    Exemplo para execução híbrida (Multithread + Multitask)

    Neste exemplo serão iniciados 20 processos, 1 processo por nó, e cada processo irá executar com 128 threads, totalizando 2560 threads, cada thread executando em um core de cada nó.

    #PBS -N meuteste
#PBS -q expressa
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=128
mpirun -np 20 -ppn 1  nome_do_programa

  9. Processamento na fila memshort

    Fila para execução de programas que utilizam recursos de paralelização multithread (SMP), multitask (MPI) e híbrida multitask+multithread (MPI+SMP) e recursos de mémória de até 2TB RAM.

    • Utilização fixa de um nó exclusivo e 128 cores
    • Tempo máximo de processamento (walltime): 2 dias
    • Diretivas necessárias:
      • #PBS -q memshort
      • #PBS -l nodes=1:ppn=128

    Exemplo de execução multithread (SMP)

    #PBS -N meuteste
#PBS -q memshort
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=128
nome_do_programa

    Exemplo de execução multitask (MPI)

    #PBS -N meuteste
#PBS -q memshort
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
mpirun -np 128  nome_do_programa

    Exemplo de execução híbrida (Multithread + Multitask)

    Neste exemplo serão iniciados 64 processos e cada processo irá executar com 2 threads, num total de 128 threads, cada thread em um core do nó.

    #PBS -N meuteste
#PBS -q memshort
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=2
mpirun -np 64  nome_do_programa

  10. Processamento na fila memlong

    Fila para execução de programas que utilizam recursos de paralelização multithread (SMP), multitask (MPI) e híbrida multitask+multithread (MPI+SMP) e recursos de mémória de até 2TB RAM.

    • Utilização fixa de um nó exclusivo e 128 cores;
    • Tempo máximo de processamento (walltime): 15 dias
    • Diretivas necessárias:
      • #PBS -q memlong
      • #PBS -l nodes=1:ppn=128

    Exemplo de execução multithread (SMP)

    #PBS -N meuteste
#PBS -q memlong
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=128
nome_do_programa

    Exemplo de execução multitask (MPI)

    #PBS -N meuteste
#PBS -q memlong
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
mpirun -np 128  nome_do_programa

    Exemplo de execução híbrida (Multithread + Multitask)

    Neste exemplo serão iniciados 64 processos e cada processo irá executar com 2 threads, num total de 128 threads, cada thread em um core do nó.

    #PBS -N meuteste
#PBS -q memlong
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=2
mpirun -np 64  nome_do_programa

  11. Processamento na fila umagpu

    Fila para execução de programas que utilizam recursos de paralelização multithread (SMP), multitask (MPI) e híbrida multitask+multithread (MPI+SMP) e recursos de processamento vetorial (GPU)

    • Utilização fixa de um nó, 16 cores e uma GPU;
    • Tempo máximo de processamento (walltime): 7 dias
    • Diretivas necessárias:
      • #PBS -q umagpu

    Exemplo para execução multithread (SMP)

    #PBS -N meuteste
#PBS -q umagpu
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=16
nome_do_programa

    Execução teste multitask (MPI)

    #PBS -N meuteste
#PBS -q umagpu
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
mpirun -np 16  nome_do_programa

    Exemplo para execução híbrida (Multithread + Multitask)

    Neste exemplo serão iniciados 8 processos e cada processo irá executar 2 threads, totalizando 16 threads, cada thread em um core do nó e todas as threads compartilhando recursos em uma GPU.

    #PBS -N meuteste
#PBS -q umagpu
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=2
mpirun -np 8  nome_do_programa

  12. Processamento nas filas miggpu e miggpu24h

    Fila para execução de programas que utilizam recursos de paralelização multithread (SMP), multitask (MPI) e híbrida multitask+multithread (MPI+SMP) e recursos de processamento vetorial (GPU). Indicada para jobs que nao fazem uso dos recursos de uma GPU inteira durante a maior parte da execução.

    • Utilização fixa de um nó, 8 cores, 30G de RAM e uma MIG (Multi Instance GPU) com metade dos recursos de processamento e memória de uma GPU Nvidia A100 40GB;
    • Tempo máximo de processamento (walltime): 7 dias (miggpu) ou 24h (miggpu24h)
    • Diretivas necessárias:
      • #PBS -q miggpu
        • ou
      • #PBS -q miggpu24h

    Exemplo para execução multithread (SMP)

    #PBS -N meuteste
### Escolha miggpu ou miggpu24h abaixo, de acordo com sua estimativa de tempo de seu job
#PBS -q miggpu
### PBS -q miggpu24h
#PBS -e erros
#PBS -o saida

# Caso seu software nao detecte a MIG como uma GPU, descomente a linha abaixo

unset CUDA_VISIBLE_DEVICES

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=8
nome_do_programa

    Execução teste multitask (MPI)

    #PBS -N meuteste
#PBS -q miggpu
#PBS -e erros
#PBS -o saida

# Caso seu software nao detecte a MIG como uma GPU, descomente abaixo

unset CUDA_VISIBLE_DEVICES

cd $PBS_O_WORKDIR

module load modulefile
mpirun -np 8  nome_do_programa

    Exemplo para execução híbrida (Multithread + Multitask)

    Neste exemplo serão iniciados 4 processos e cada processo irá executar 2 threads, totalizando 8 threads, cada thread em um core do nó e todas as threads compartilhando recursos em uma GPU.

    #PBS -N meuteste
#PBS -q umagpu
#PBS -e erros
#PBS -o saida

# Caso seu software nao detecte a MIG como uma GPU, descomente abaixo
# unset CUDA_VISIBLE_DEVICES

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=2
mpirun -np 4  nome_do_programa

  13. Processamento na fila duasgpus

    Fila para execução de programas que utilizam recursos de paralelização multithread (SMP), multitask (MPI) e híbrida multitask+multithread (MPI+SMP) e recursos de processamento vetorial (GPU)

    • Utilização fixa de um nó, 32 cores e duas GPUs;
    • Tempo máximo de processamento (walltime): 3 dias
    • Diretivas necessárias:
      • #PBS -q duasgpus

    Exemplo de execução multithread (SMP)

    #PBS -N meuteste
#PBS -q duasgpus
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=32
nome_do_programa

    Exemplo de execução multitask (MPI)

    #PBS -N meuteste
#PBS -q duasgpus
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
mpirun -np 32  nome_do_programa

    Exemplo de execução híbrida (Multithread + Multitask)

    Neste exemplo serão iniciados 16 processos e cada processo irá executar 2 threads, totalizando 32 threads, cada thread em um core do nó e todas as threads compartilhando recursos em duas GPUs.

    #PBS -N meuteste
#PBS -q duasgpus
#PBS -e erros
#PBS -o saida

cd $PBS_O_WORKDIR

module load modulefile
export OMP_NUM_THREADS=2
mpirun -np 16  nome_do_programa
Voltar ao topo