ParaView¶

Este guia adapta boas práticas de outros centros HPC para o ambiente local do CS2I, com recomendações para utilização com Slurm, GPUs (EGL) e uso client-server.

1. Visão geral¶

Antes de iniciar, vale alinhar a finalidade: processar e visualizar dados grandes diretamente no cluster, no storage de alto desempenho, com MPI (para paralelizar leitura/filtros) e EGL (para renderizar sem servidor gráfico). Isso minimiza transferência de grandes volumes de dados para sua estação local e melhora a responsividade.

Benefício esperado: menor gargalo de I/O, melhor uso de CPU/GPU e workflows reprodutíveis por script ou client-server.

2. Conceitos e arquitetura¶

Entender a arquitetura evita frustrações com X11 e compatibilidade de versões:

Client–Server: o client (GUI paraview) roda no seu desktop; o server (pvserver) roda no nó de computação, onde estão os dados. A conexão ocorre por socket TCP via túnel SSH. Este modelo oferece melhor desempenho que X11 forwarding e é a abordagem recomendada.
EGL (headless GPU): permite renderizar em GPU sem DISPLAY, ideal para nós de computação. Use --force-offscreen-rendering em pvserver/pvbatch.
Batch: tarefas repetitivas ou longas podem ser automatizadas com pvbatch/pvpython, garantindo reprodutibilidade.
Compatibilidade de versão: o client da sua estação deve corresponder à versão do servidor para evitar erros de protocolo.

3. Pré‑requisitos e recomendações¶

Para evitar o interrompimento do paraview e garantir boa convivência no ambiente:

Onde executar: nunca rode paraview nos nós de login. Lance um allocation (salloc/sbatch/srun) com Slurm e execute no nó alocado.
Paths de trabalho: use /scratch/projetos/<projeto> e, quando aplicável, /scratch/$USER para dados e saídas. Reserve ~/ para scripts leves e arquivos de configurações.
Partições: selecione partição CPU para pós‑processamento sem renderização em GPU e GPU quando desejar aceleração de render.
Rede/portas: conexões diretas ao nó de computação podem ser bloqueadas. Prefira túnel SSH.
GUI: baixe localmente (sua estação de trabalho) a mesma versão do ParaView que está rodando no cluster. ParaView Download webpage.

4. Carregando o módulo ParaView¶

Antes de executar, garanta a stack correta (MPI, Python e plugins) usando o módulo oficial.

Por que fazer isso: evitar conflito de bibliotecas com mpi, mesa, qt ou Python do sistema.

Comando:

module load paraview/5.13.3-egl-mpi-python3.10

Validação rápida:

module list
which pvserver pvbatch pvpython

5. Client-Server com `pvserver` (recomendado)¶

O modelo client-server oferece interatividade eficiente para grandes dados, delegando o processamento intensivo ao cluster.

Fluxo: alocar recursos (Slurm) → iniciar pvserver (nó de computação) → conectar GUI local (túnel SSH).

Alocar recursos (exemplo com 1 GPU e 8 ranks):

salloc --partition=gpulongc --nodes=1 --ntasks-per-node=8 --time=02:00:00

Iniciar o servidor (modo offscreen EGL):

module load paraview/5.13.3-egl-mpi-python3.10

# evita oversubscription junto ao MPI
export OMP_NUM_THREADS=1

srun -n 8 pvserver --server-port=11111 --force-offscreen-rendering

Conectar a partir do desktop (túnel SSH):

Utilize o túnel SSH caso a porta do nó de computação não esteja acessível diretamente.

ssh -N -L 11111:<compute-node>:11111 <usuario>@<login-node>

Depois, no client (GUI), crie uma conexão para localhost:11111 em File → Connect….

Dicas adicionais:

Para múltiplas GPUs, verifique mapeamento com CUDA_VISIBLE_DEVICES ou bindings do MPI.
Se observar erros OpenGL, entre em contato com o suporte.

6. Uso interativo em nó de computação (EGL/headless)¶

Para análises rápidas, sem a GUI remoto, use sessões interativas com scripts direto no nó.

Fluxo: alocar nó → carregar módulo → executar operações EGL/Python headless.

Alocação e verificação:

salloc --partition=gpulongc --nodes=1 --ntasks-per-node=1 --time=02:00:00

module load paraview/5.13.3-egl-mpi-python3.10

pvpython --version

Observação: a GUI paraview não deve ser usada via X11 forwarding; prefira o modelo client-server.

7. Execução em lote com `pvbatch`/`pvpython`¶

Execuções em lote dispensam interação manual, facilitando a escalabilidade e reprodutibilidade.

Logica: encapsular operações em Python habilita reprodução, controle de versão e execução distribuída via srun.

Exemplo de script batch (render offscreen com MPI):

#!/bin/bash
#SBATCH --job-name=pvbatch_render
#SBATCH --partition=gpulongc
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=8
#SBATCH --time=01:00:00
#SBATCH --output=logs/%x-%j.out

module load paraview/5.13.3-egl-mpi-python3.10
export OMP_NUM_THREADS=1
srun -n 8 pvbatch /scratch/$USER/scripts/render.py

Script Python mínimo (pipeline básico):

O objetivo é demonstrar leitura, mapeamento de cor e screenshot.

from paraview.simple import *
reader = OpenDataFile('/scratch/$USER/dados/case_001.vti')
view = CreateView('RenderView')
Show(reader, view)
ColorBy(GetDisplayProperties(reader, view=view), ('POINTS', 'pressure'))
ResetCamera(view)
view.ViewSize = [1920, 1080]
SaveScreenshot('/scratch/$USER/saidas/case_001.png', view)

Submeter job:

sbatch pvbatch_render.sbatch

Dica: gerar um .pvsm pela GUI e reproduzir com pvbatch --state acelera a criação de pipelines complexos.

8. Otimização e boas práticas¶

Para obter throughput consistente, considere:

I/O local ao compute: leia/escreva em /scratch para reduzir latência do FS compartilhado.
Formatos paralelizáveis: prefira HDF5, coleções .pvd/.vtm e time-series particionadas.
Decomposição e filters paralelos: alinhe o número de ranks à decomposição do dataset; evite oversubscription fixando OMP_NUM_THREADS=1.
LOD e caching: use LOD para navegação interativa; para frames finais, desative LOD. Ajuste cache conforme memória disponível.
GPU headless: sempre use --force-offscreen-rendering para EGL; valide drivers com nvidia-smi no contexto do job.
Render progressivo: para animações, salve keyframes em resolução menor durante testes; aumente para produção.

9. FAQ¶

Principais problemas e sugestões rápidas de diagnóstico:

GUI remota lenta/erros OpenGL: evite X11 forwarding; use client-server. Se persistir erro, teste variante mesa (quando existir), revise drivers ou contate o suporte.
Conexão recusada: use túnel SSH (-L); confirme host/porta corretos e políticas de firewall internas.
MPI incompatível: carregue o módulo do ParaView e use srun (não misture mpirun externo). Verifique module list dentro do job.
Sem GPU visível: confirme com nvidia-smi dentro do allocation.
Memória insuficiente: aumente ranks, reduza resolução, fatie o domínio (tiles/slabs) ou serialize time-steps.
Problemas persistentes: para suporte técnico, consulte Como solicitar ajuda.

10. Exemplos ilustrativos¶

Estes exemplos servem de ponto de partida; ajuste partição/conta conforme seu projeto e HPC.

10.1. Sessão com 1 GPU e 8 ranks (EGL):

Visa sessões interativas com client-server de alta responsividade.

salloc --partition=gpulongc --nodes=1 --ntasks-per-node=8 --gres=gpu:1 --time=02:00:00
module load paraview/5.13.3-egl-mpi-python3.10
export OMP_NUM_THREADS=1
srun -n 8 pvserver --server-port=11111 --force-offscreen-rendering

10.2. Túnel SSH a partir do desktop:

Encaminha a porta local para o nó de computação alocado.

ssh -N -L 11111:<compute-node>:11111 <usuario>@<login-node>

Depois conecte a localhost:11111 em File → Connect….

10.3. Sessão CPU‑only (16 ranks):

Útil para pipelines sem renderização acelerada por GPU.

salloc --partition=cpulongc --nodes=1 --ntasks-per-node=16 --time=01:00:00
module load paraview/5.13.3-egl-mpi-python3.10
export OMP_NUM_THREADS=1
srun -n 16 pvbatch /scratch/$USER/scripts/postpro.py

10.4. Reproduzir um State em lote:

Facilita levar um pipeline criado na GUI para o modo batch.

srun -n 8 pvbatch --state=/scratch/$USER/states/case.pvsm --data=/scratch/$USER/dados/

11. Conclusão¶

Use o client-server para interatividade e o batch para processamento. Padronize o carregamento do módulo paraview/5.13.3-egl-mpi-python3.10, trabalhe no /scratch, e dimensione o MPI/GPUs conforme a decomposição do seu dataset. Em caso de dúvidas, compartilhe seu sbatch, allocation e logs para diagnóstico rápido pelo time NOC/HPC.