Afinação do Kernel Linux para Servidores de IA: O Que Faz Mesmo Diferença
O kernel padrão do Ubuntu numa stack HWE 6.8 ou 6.11 chega perfeitamente para cerca de 80% das cargas de trabalho de IA. Este artigo é para os outros 20% — EPYC multissocket a empurrar oito GPU, uma máquina de serving com vLLM a bater num limite de vm.max_map_count sob carga, ou um servidor de inferência cuja latência de cauda está a ser consumida por transições de C-state do CPU.
A maior parte dos conselhos públicos sobre "tuning de Linux para IA" é orientação de bases de dados reciclada de 2015 e uma fatia nada despicienda dela piora discretamente a latência de inferência. Em baixo fica o conjunto mais pequeno e honesto de alterações que realmente ajudam numa máquina Kentino AI de classe Kentino (4 a 8 GPU em Xeon ou EPYC, Ubuntu 22.04 / 24.04, kernel 6.x). Parte-se do princípio de que o driver e a stack CUDA estão instalados conforme L01 e L02.
A hierarquia honesta dos ganhos
Antes de qualquer alteração de sysctl, convém perceber o tamanho do prémio:
| Alteração | Ganho típico em inferência / treino |
|---|---|
| Colocação de processos com consciência de NUMA | 10–30% em máquinas multissocket |
Governor do CPU em performance (em vez de powersave) |
5–15% em máquinas de serving, TTFT mais baixo |
| Desativar C-states profundos | Microssegundos a menos no P99, +30–50 W em inatividade / socket |
THP definido como madvise
|
1–5% em PyTorch, menos bloqueios com memória em rotação |
vm.max_map_count, ulimit -n
|
Evita que o serving caia sob carga |
| Afinidade de IRQ ao nó NUMA local | 5–15% em caminhos de DataLoader em rede / RDMA |
Dimensionamento dos buffers TCP (rmem_max, wmem_max) |
Só conta acima de 25 GbE em armazenamento / streaming |
| Tudo o resto | 0–3%, muitas vezes ruído |
Se não retiver mais nada deste artigo: a consciência de NUMA e o governor do CPU são os dois grandes ganhos. Todo o resto é erro de arredondamento, a menos que o tenha medido.
Governor do CPU: os 5–15% mais baratos que existem
O Ubuntu assume por omissão powersave (intel_pstate) ou ondemand (acpi_cpufreq), consoante o driver. Ambos sobem as frequências de forma reativa, o que custa 5–15% no TTFT de inferência e na preparação do lado do CPU em redor de um forward pass do vLLM — tokenização, escalonamento, amostragem de logits.
Numa máquina de serving, defina performance e esqueça o assunto:
sudo apt install -y cpufrequtils
echo 'GOVERNOR="performance"' | sudo tee /etc/default/cpufrequtils
sudo systemctl restart cpufrequtils
# Verify
for c in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do cat $c; done | sort -u
Em EPYC Genoa / Turin com kernel 6.5+, o driver amd-pstate substitui o acpi-cpufreq. A ideia é a mesma: definir scaling_governor como performance. O modo mais recente amd-pstate-epp mantém o desempenho permitindo boost por core; deixe o EPP em performance, não em balance_performance.
Ressalva: numa máquina de treino com utilização de GPU sustentada perto dos 100%, os CPU estão carregados de qualquer forma e o governor pesa menos. O grande ganho está nos servidores de inferência que ficam inativos entre pedidos e precisam de subir de frequência instantaneamente.
NUMA: a diferença entre uma máquina EPYC rápida e uma medíocre
Servidores Xeon ou EPYC de socket único não têm nada a decidir — um só nó NUMA, todos os acessos à memória são locais. É nas máquinas de dois sockets que vivem os 10–30%.
O escalonador por omissão coloca alegremente um worker vLLM no socket 0 e deixa-o fazer page fault para memória alocada no socket 1 — cada carregamento é um salto cruzado por UPI / Infinity Fabric. Para um modelo com centenas de GB de pesos percorridos uma vez por token, isto é real.
Para inspecionar:
numactl --hardware # node count, sizes, distance matrix
nvidia-smi topo -m # GPU↔CPU NUMA affinity
cat /sys/class/net/<iface>/device/numa_node # NIC NUMA affinity
O padrão que quer — e que o NCCL deteta automaticamente — é a GPU N fixada ao nó NUMA que aloja o seu complexo raiz PCIe, e não ao outro socket. Num processo de inferência lançado à mão, fixe tanto o CPU como a memória ao nó local:
# vLLM on a 2-socket EPYC, GPUs 0–3 on NUMA node 0
numactl --cpunodebind=0 --membind=0 \
python -m vllm.entrypoints.openai.api_server \
--model meta-llama/Llama-3.3-70B-Instruct --tensor-parallel-size 4
Dois parâmetros relacionados:
-
kernel.numa_balancingmigra páginas para junto do CPU que lhes toca. Útil em cargas de trabalho genéricas, por vezes contraproducente em IA: um prefill percorre os pesos uma vez, o kernel migra as páginas e o pedido seguinte volta a puxá-las. Deixe ligado por omissão (1); se o jitter estiver correlacionado comnuma_pte_updatesem/proc/vmstat, experimentesysctl kernel.numa_balancing=0. -
NCCL em dois sockets — defina
NCCL_SOCKET_IFNAMEpara a NIC de gestão eNCCL_IB_HCApara a NIC no mesmo nó NUMA das GPU. A NIC errada reduz a metade, em silêncio, o débito entre nós.
Servidor EPYC 9004/9005 de socket único: ignore esta secção por completo.
Transparent Huge Pages: madvise, não always
As THP juntam páginas de 4 KB em páginas de 2 MB de forma oportunista, reduzindo a pressão sobre o TLB. O PyTorch e o driver CUDA beneficiam de forma modesta. A armadilha é o modo always com memória em rotação — o kernel bloqueia uma thread durante 50–100 ms a compactar memória, destruindo qualquer SLO de latência.
A definição correta é madvise: as aplicações que sabem o que fazem chamam madvise(MADV_HUGEPAGE) em alocações de vida longa e obtêm THP; as restantes não. Defina em /etc/default/grub:
GRUB_CMDLINE_LINUX_DEFAULT="... transparent_hugepage=madvise"
update-grub && reboot. A desfragmentação deve acompanhar — defer+madvise permite que a compactação aconteça em segundo plano e não no caminho da thread que aloca:
echo defer+madvise | sudo tee /sys/kernel/mm/transparent_hugepage/defrag
Para vLLM / SGLang / TensorRT-LLM em produção, madvise é o valor por omissão correto. O PyTorch com CUDA Unified Memory (código de investigação) por vezes beneficia de always — meça antes de mudar.
Hugepages explícitas de 1 GB: só se tiver medido
As hugepages explícitas reservadas no arranque através de hugetlbfs dão um pequeno ganho adicional em pesos de LLM muito grandes, ao eliminarem falhas de TLB na varredura dos pesos. O senão: a memória é reservada à partida e fica indisponível para o resto do sistema, a aplicação tem de ser construída para as usar e o ganho é de 1–3% na maioria das cargas de serving.
GRUB_CMDLINE_LINUX_DEFAULT="... default_hugepagesz=1G hugepagesz=1G hugepages=64"
Vale a pena numa máquina TensorRT-LLM em que o engine cabe em memória fixada e em que se persegue o último ponto percentual de TTFT. Não vale a pena num servidor vLLM genérico que troca de modelos nem em qualquer máquina de treino. Ignore numa primeira montagem; reavalie apenas se perf stat -e dTLB-load-misses mostrar pressão no TLB e se tiver RAM de sobra.
vm.max_map_count e nofile: as paredes contra as quais o vLLM bate em escala
O valor por omissão de vm.max_map_count no Ubuntu é 65530 — o número de mapeamentos de memória distintos que um processo pode manter. O vLLM a servir um modelo grande com concorrência elevada, ou qualquer framework que use muitos shards safetensors em mmap, ultrapassa isto e morre com Cannot allocate memory. O valor 262144 herdado do Elasticsearch é o mínimo absoluto; para vLLM a servir 70B+ com centenas de sequências concorrentes, suba até 1048576. Não custa nada — é um limite flexível, não uma reserva.
O ulimit -n por omissão no Ubuntu é 1024. Comicamente baixo: vLLM, Triton, workers do DataLoader do PyTorch, NCCL e a camada gRPC entre eles abrem centenas de descritores cada um. Chegando ao limite, recebe EMFILE: too many open files e um processo que encrava em silêncio.
# /etc/sysctl.d/99-ai-server.conf
vm.max_map_count = 1048576
# /etc/security/limits.d/99-ai-server.conf
* soft nofile 1048576
* hard nofile 1048576
# /etc/systemd/system.conf.d/99-limits.conf
[Manager]
DefaultLimitNOFILE=1048576
sudo sysctl --system e systemctl daemon-reexec. Confirme com ulimit -n e cat /proc/<pid>/limits.
Afinidade de IRQ: fixar as interrupções da NIC a CPU locais
Numa NIC ConnectX-6/7 de 100 GbE a sustentar mais de 10 GB/s de streaming de datasets ou de tráfego RDMA, as interrupções têm de aterrar em CPU (a) no mesmo nó NUMA da NIC e (b) que não sejam os mesmos cores a correr os workers do DataLoader. O irqbalance por omissão faz um trabalho razoável; sob carga pesada, já não.
A solução mais limpa é o set_irq_affinity.sh da Mellanox, incluído no mlnx-tools:
sudo systemctl disable --now irqbalance
sudo /usr/sbin/set_irq_affinity.sh enp1s0f0 # all NIC-local cores
sudo /usr/sbin/set_irq_affinity_cpulist.sh 4-11 enp1s0f0 # pin to specific cores
O erro a evitar é deixar o irqbalance a correr numa máquina onde também fixou interrupções à mão — eles entram em conflito. Escolha um. Máquina de serving com uma ou duas NIC RDMA: fixe à mão e desative o irqbalance. Máquina de uso geral com muitas interfaces: deixe o irqbalance ligado com --banirq para excluir a NIC crítica.
Buffers de rede do kernel: só para caminhos de armazenamento / streaming rápidos
Para um servidor de inferência de nó único a falar com clientes por TCP simples a débitos moderados, os valores por omissão de net.core.rmem_max / wmem_max de 208 KB chegam bem. Para um nó que puxa dados de treino de NFS a 100 GbE ou de um object store, ou para um frontend vLLM atrás de um balanceador de carga com muitos pedidos por segundo, os valores por omissão são o teto da sua largura de banda. Um conjunto inicial para uma máquina ligada a 100 GbE:
# /etc/sysctl.d/99-ai-network.conf
net.core.rmem_max = 268435456
net.core.wmem_max = 268435456
net.ipv4.tcp_rmem = 4096 87380 268435456
net.ipv4.tcp_wmem = 4096 65536 268435456
net.core.netdev_max_backlog = 250000
net.core.somaxconn = 65535
Um máximo de 256 MB é exagerado para 100 GbE dentro do rack (o BDP anda pelos 1.25 MB), mas é inofensivo — o auto-tuning do TCP só faz crescer os buffers conforme necessário até ao limite. Em RDMA (RoCE / IB) para o caminho de dados estes parâmetros não interessam — o RDMA contorna a stack TCP do kernel. Continuam a interessar para o plano de gestão, para NFS e para descarregar modelos.
C-states: latência versus consumo em inatividade
Numa máquina de serving sensível à latência, a melhoria mais barata na latência de cauda, a seguir ao governor do CPU, é desativar os C-states profundos. A entrada e saída de C6 demora dezenas de microssegundos; num pedido que deve responder em 30 ms, um CPU a sair de C6 para tratar da amostragem pós-token acrescenta jitter percetível.
GRUB_CMDLINE_LINUX_DEFAULT="... intel_idle.max_cstate=1 processor.max_cstate=1"
update-grub && reboot. Confirme com cpupower idle-info — só C0 e C1 devem estar disponíveis. Custo: 30–50 W de consumo em inatividade por socket, porque os cores nunca entram em sono profundo. Num servidor de dois sockets e 8 GPU, são 60–100 W de sobrecarga permanente — irrisório face a 3.5–4.5 kW de consumo sustentado das GPU sob carga.
Aplique a servidores de inferência sensíveis à latência e a caminhos de robótica em tempo real. Ignore em máquinas de treino (a latência não interessa e o consumo em inatividade acumula ao longo de meses) e em trabalhos por lotes.
Tuning do kernel relacionado com o sistema de ficheiros (antevisão do L04)
Há um punhado de sysctls fs.* que interessam:
fs.aio-max-nr = 1048576 # default 65536 too low for vLLM weight loaders
fs.inotify.max_user_watches = 524288 # tooling that watches checkpoint dirs
fs.aio-max-nr é o que mais morde — frameworks que fazem I/O assíncrono sobre muitos shards (DALI, carregadores de pesos do vLLM) esgotam os 65536 por omissão em modelos grandes. A escolha do próprio sistema de ficheiros (XFS vs ZFS vs ext4), as opções de montagem e a semântica de O_DIRECT ficam para L04.
Desativar módulos do kernel desnecessários
Uma máquina de serving sem monitor não tem nada que carregar módulos de bluetooth, som, webcam, wireless, joystick ou servidor de impressão. Cada um é mais código na superfície de ataque e um pequeno atraso no arranque. Individualmente é trivial; no conjunto, uma máquina mais limpa é mais fácil de compreender.
# /etc/modprobe.d/blacklist-ai-server.conf
blacklist bluetooth
blacklist btusb
blacklist snd_hda_intel
blacklist uvcvideo
blacklist joydev
# Plus
sudo systemctl disable --now bluetooth.service cups.service avahi-daemon.service \
ModemManager.service whoopsie.service apport.service
O arranque desce de cerca de 30 s para cerca de 10 s numa montagem EPYC típica e o lsmod volta a ser legível. Impacto zero no desempenho de inferência, redução modesta da superfície de ataque.
Dois perfis: inferência versus treino
O formato do tuning é genuinamente diferente. Esboços prontos a usar:
Inferência (/etc/sysctl.d/99-ai-inference.conf)
vm.max_map_count = 1048576
vm.swappiness = 1
vm.overcommit_memory = 1
kernel.numa_balancing = 1
fs.aio-max-nr = 1048576
net.core.rmem_max = 268435456
net.core.wmem_max = 268435456
net.ipv4.tcp_rmem = 4096 87380 268435456
net.ipv4.tcp_wmem = 4096 65536 268435456
net.core.netdev_max_backlog = 250000
net.core.somaxconn = 65535
Mais, na linha de comandos do kernel: transparent_hugepage=madvise intel_idle.max_cstate=1 processor.max_cstate=1. Governor: performance. IRQ da NIC fixadas a cores locais do nó NUMA, irqbalance desligado.
Treino (/etc/sysctl.d/99-ai-training.conf)
vm.max_map_count = 1048576
vm.swappiness = 1
vm.overcommit_memory = 1
kernel.numa_balancing = 0 # page migration mid-epoch is just churn
fs.aio-max-nr = 1048576
fs.inotify.max_user_watches = 524288
net.core.rmem_max = 536870912
net.core.wmem_max = 536870912
net.ipv4.tcp_rmem = 4096 131072 536870912
net.ipv4.tcp_wmem = 4096 131072 536870912
Linha de comandos do kernel: transparent_hugepage=madvise (sem fixação de C-states — o treino é limitado pelo débito e o consumo em inatividade acumula ao longo de semanas). Governor: performance, se tiver orçamento energético para isso. NCCL fixado ao NUMA local através de NCCL_IB_HCA.
A armadilha do "afinei tudo e ficou mais lento"
O modo de falha mais comum é a descarga em modo seita: copiar uma centena de sysctls de um artigo de blogue, reiniciar, observar pior desempenho e não fazer ideia de que parâmetro reverter. O método que funciona:
- Estabeleça uma linha de base —
nccl-tests all_reduce_perf,benchmark_throughput.pydo vLLM, tempo por passo de treino. Aponte os números. - Mude uma coisa de cada vez.
- Repita o mesmo benchmark, três vezes, por causa do ruído.
- Mantenha se a mediana melhorar de forma significativa. Reverta se não.
- Documente a alteração e o motivo, em controlo de versões, ao lado do ficheiro de sysctl.
Já vimos máquinas em produção com 40 linhas de tuning de sysctl que, no conjunto, eram 2% mais lentas do que os valores por omissão do Ubuntu — cada alteração individual neutra ou pior, mas com o operador convencido de que "o tuning ajuda".
O tuned 2.27 da Red Hat já traz perfis ai-inference e ai-training explícitos e é um atalho credível em RHEL / Rocky. O Ubuntu não o inclui; o apt install tuned funciona, mas é menos polido. No Ubuntu, ficheiros próprios em /etc/sysctl.d/ e uma linha de comandos do GRUB limpa são mais fáceis de auditar e sabe-se exatamente o que está definido.
O que fazer a seguir
Uma sequência razoável de tuning de kernel para uma montagem Kentino AI nova da Kentino, por ordem de prioridade:
-
Defina o governor do CPU como
performance. Confirme comcpupower frequency-info. O maior ganho sem custo. -
Corra
numactl --hardwareenvidia-smi topo -m. Perceba a topologia antes de fixar seja o que for. Em máquinas de dois sockets, planeie que GPU ficam com que nó NUMA. -
Defina
vm.max_map_counte os limites denofile. Isto evita falhas, não lentidão. Faça-o antes da primeira execução em produção. -
Defina
transparent_hugepage=madvisena linha de comandos do kernel. -
Fixe as IRQ da NIC ao nó NUMA local da NIC com
set_irq_affinity.sh. Desative oirqbalancese o tiver feito. -
Apenas em máquinas de inferência: desative os C-states profundos com
intel_idle.max_cstate=1 processor.max_cstate=1. - Afine os buffers de rede só se tiver medido um estrangulamento num caminho de armazenamento ou de streaming a 25/100 GbE.
- Ignore as hugepages explícitas de 1 GB a não ser que tenha um benchmark a mostrar pressão no TLB.
- Meça antes e depois de cada alteração. Uma coisa de cada vez. Documente.
Referências cruzadas: L01 para o driver e a fixação de versões do kernel, L02 para a stack CUDA / contentores, L04 para a camada de sistema de ficheiros, L05 para monitorização.
O tuning de kernel no Linux moderno é, sobretudo, configuração feita uma vez, e não um jogo contínuo de otimização. Acerte no governor, na colocação NUMA e nos limites. Ignore o resto, a menos que o seu benchmark diga o contrário.
Este artigo faz parte da Kentino Wiki, uma série de referência sobre computação de IA, robótica e os sistemas que os ligam. Comentários e correções são bem-vindos em info@kentino.com.