Pular para o conteúdo
Notícias e tutoriais sobre Linux
Kernel Linux

Valve prepara correção no Linux para reduzir engasgos em jogos Windows rodando com Proton

Frametime mais estável para o pinguim!

reduzir stuttering jogos proton linux

Quando um jogo engasga no Linux através do Proton, a comunidade costuma apontar imediatamente para um suspeito habitual: a compilação de shaders. O problema é que nem todo microtravamento nasce desse processo. Uma nova série de alterações enviada para o driver de vídeo AMDGPU quer remover uma fonte muito mais silenciosa de stuttering, relacionada à forma como a memória de vídeo é gerenciada durante a execução de alguns jogos originalmente feitos para Windows.

O trabalho foi enviado em 17 de novembro de 2026 por Natalie Vock, desenvolvedora Linux que atua como contratada independente para a Valve. A proposta, que encontra-se na versão 2 (v2) e conta com 10 patches, altera estruturas profundas de comunicação entre o sistema e a placa de vídeo. O objetivo não é aumentar a média de quadros por segundo (FPS), mas sim atacar picos irregulares no tempo de renderização de cada quadro, um fenômeno conhecido como frametime irregular.

A autora afirma que cargas de trabalho que fazem uso intenso de determinadas operações de memória, particularmente alguns jogos executados sob o Proton, podem obter reduções significativas nos engasgos se o código for aprovado e integrado ao kernel.

O problema não é shader compilation desta vez

Para entender a novidade, é preciso olhar para a forma como os jogos modernos lidam com mundos virtuais extensos. Muitos títulos utilizam recursos gráficos de mapeamento dinâmico, frequentemente chamados de sparse bindings ou Partially Resident Textures (PRT).

Imagine uma textura gigantesca, como o mapa inteiro de uma cidade detalhada. Em vez de manter todos esses dados pesados permanentemente ocupando a memória física da placa de vídeo (VRAM), o jogo pode criar um grande recurso virtual e mapear apenas as partes necessárias para aquele exato momento da jogatina.

Conforme o jogador vira a câmera ou muda de cenário, novas regiões do mapa são alocadas na memória, enquanto partes antigas são descartadas. Isso torna o uso da VRAM muito mais eficiente, mas cria um efeito colateral: o jogo precisa realizar centenas ou milhares de pequenas atualizações de mapeamento (map e unmap) constantemente. O gargalo que a série de patches tenta resolver mora exatamente na forma como o Linux lida com esse tráfego de atualizações.

Por que o AMDGPU pode interromper outras tarefas da GPU?

reduzir stuttering jogos proton linux 1
Valve prepara correção no Linux para reduzir engasgos em jogos Windows rodando com Proton 3

Atualmente, quando esses mapas PRT são atualizados, o driver AMDGPU acaba adotando uma postura de segurança excessivamente ampla. As alterações de memória são sincronizadas com outras submissões na mesma máquina virtual (VM) da GPU.

Na prática, as placas de vídeo possuem mecanismos diferentes trabalhando ao mesmo tempo. Existe a fila de renderização gráfica (GFX), a fila de cálculos gerais (Compute) e o mecanismo de movimentação de dados (SDMA). A intenção de um motor gráfico otimizado é que essas tarefas se sobreponham.

O que acontece hoje é que, devido ao modelo de sincronização implícita, as atualizações sparse acabam forçando a placa de vídeo a aguardar por trabalhos gráficos e de computação que não têm dependência direta com aquela alteração de memória. Se o volume dessas operações for intenso, as filas gráficas podem ficar bloqueadas. A renderização do quadro atrasa e o jogador percebe o engasgo na tela.

O gargalo de uma chamada por operação

O método atual possui uma segunda limitação. Para que o mapeamento de memória aconteça, o programa (neste caso, o jogo rodando via Proton e traduzido pelo Vulkan) precisa pedir para o kernel do Linux executar a alteração. Essa comunicação é feita através de uma chamada de sistema conhecida como ioctl.

No modelo anterior, cada pequena atualização de mapa exigia uma ida e volta individual entre o espaço do usuário (userspace) e o kernel. Quando um jogo faz milhares de alterações em um curto espaço de tempo, o custo de processamento (overhead) exigido apenas para fazer essas transições se acumula, roubando tempo valioso de processamento da CPU.

O novo AMDGPU_GEM_VA2

A peça central do trabalho enviado por Vock é a introdução de uma interface modernizada para o driver, batizada tecnicamente de AMDGPU_GEM_VA2. Ela substitui a antiga interface de mapeamento e traz duas mudanças estruturais para o gerenciamento de memória no Linux.

Várias operações enviadas de uma só vez

A primeira grande novidade é o suporte a batching. Em vez de mandar uma alteração de memória de cada vez ao kernel, o driver agora consegue receber um pacote com dezenas de operações em uma única chamada ioctl. Isso reduz drasticamente a carga sobre o processador e o trânsito entre o userspace e o kernel.

Para garantir que esse processo funcione de forma segura, os patches criam uma nova estrutura chamada VM update context. Esse contexto rastreia todas as alterações pendentes e valida o pacote inteiro antes de aplicar qualquer mudança na placa de vídeo. Se houver algum mapeamento conflitante ou erro de validação, a série inclui uma função de rollback, permitindo que o driver reverta o estado da memória para o momento exato antes da tentativa falha, evitando que o jogo congele por causa de uma instrução aplicada pela metade.

Por que esperar por tudo se você só precisa esperar pelo que importa?

A segunda evolução é a adoção de sincronização explícita. O novo AMDGPU_GEM_VA2 aceita múltiplos objetos de sincronização (syncobjs), suportando adequadamente o modelo de timeline syncobj.

No lugar de o driver do kernel tentar adivinhar as dependências e pausar várias filas da GPU por precaução, a sincronização explícita permite que o userspace informe com precisão quais tarefas realmente precisam aguardar a finalização de uma movimentação de memória. Filas de trabalho que não dependem daquele recurso específico continuam operando em paralelo.

FPS alto e jogo engasgando não são a mesma coisa

É importante não confundir o objetivo desta atualização com aumento bruto de desempenho. A proposta busca melhorar o frametime (tempo de quadro), e não apenas o FPS médio.

Um jogo pode perfeitamente reportar uma média de 80 quadros por segundo e, ainda assim, entregar uma experiência ruim. Se a maioria dos quadros leva cerca de 12 milissegundos para ser renderizada, mas uma sincronização excessiva de memória bloqueia a GPU e faz um único quadro levar 80 milissegundos, o jogador sentirá um tranco na imagem. O novo modelo tenta eliminar essa espera inútil, garantindo que o ritmo de entrega dos quadros se mantenha o mais constante possível.

Por que o kernel sozinho não resolve?

Apesar de o trabalho de Natalie Vock implementar a base necessária no nível do sistema operacional, essa mudança, isoladamente, não muda a vida do usuário. O kernel do Linux apenas oferece a nova interface AMDGPU_GEM_VA2. Alguém precisa utilizá-la.

No ecossistema de jogos do Linux, as instruções gráficas de títulos do Windows passam pelo Proton, são traduzidas para Vulkan (por ferramentas como DXVK ou VKD3D-Proton) e finalmente chegam ao driver Vulkan em userspace. Para quem utiliza hardware da AMD, esse driver costuma ser o RADV, parte do projeto open source Mesa.

Para que as reduções de stuttering sejam percebidas nos jogos, o RADV precisará ser atualizado para adotar a nova interface de mapeamento e enviar as instruções agrupadas. Para facilitar esse reconhecimento, o último patch da série incrementa a versão secundária do driver AMDGPU de 3.66 para 3.67. Dessa forma, o Mesa consegue detectar exatamente se o kernel daquele computador já entende os comandos do novo formato antes de tentar usá-los.

Quando a correção chega aos usuários?

Não existe garantia de que a novidade estará presente no próximo grande ciclo de atualização do sistema, como o esperado Linux 7.5. O processo de desenvolvimento upstream é rigoroso.

A primeira tentativa de enviar uma solução para os problemas de sincronização dos unmaps em PRT ocorreu em 29 de maio de 2026. Na época, a proposta de Vock continha apenas 3 patches. A versão atual, quase seis meses depois, cresceu para 10 patches estruturais e adicionou suporte robusto ao agrupamento de operações (batching) e ao contexto de atualização de memória.

Atualmente, o código circula nas listas de discussão técnicas públicas, onde mantenedores do subsistema gráfico podem solicitar revisões adicionais. Após a aprovação e integração no repositório principal, a novidade ainda precisará chegar às distribuições Linux, e o Mesa precisará lançar sua respectiva atualização para o RADV. Portanto, não é recomendado compilar patches experimentais na sua máquina pessoal agora, já que os componentes do espaço do usuário ainda não estão prontos para tirar proveito da mudança.

Entenda sem termos técnicos

Para visualizar como o novo sistema funciona, imagine um grande restaurante com uma cozinha movimentada. Vários cozinheiros (a placa de vídeo) estão preparando pratos ao mesmo tempo em diferentes bancadas (as filas de renderização e computação).

No sistema antigo, sempre que um ajudante precisava ir ao estoque buscar ou devolver uma caixa de ingredientes (uma alteração de memória), a regra da casa exigia que praticamente todos os cozinheiros parassem de trabalhar e esperassem o ajudante voltar, por precaução. Para piorar, o ajudante só podia carregar uma única caixa por viagem. Quando o cardápio do dia exigia buscar muitas caixas, o serviço do restaurante engasgava, e os clientes percebiam a demora em alguns pedidos.

Com o novo sistema proposto, o gerente da cozinha fica muito mais inteligente. Primeiro, o ajudante ganha um carrinho capaz de transportar dezenas de caixas de uma só vez (batching). Segundo, o gerente avisa exatamente quem precisa parar: “apenas a bancada das sobremesas precisa esperar este ingrediente; o resto de vocês pode continuar cozinhando”. Isso é a sincronização explícita. O resultado é um restaurante onde os pratos saem num ritmo muito mais constante, sem pausas desnecessárias.

RECURSOS DO ARTIGO

Links e recursos

Materiais oficiais e referências técnicas relacionadas à matéria.
QUEM ESCREVE
Emanuel Negromonte

Sobre o autor

Emanuel Negromonte é Jornalista, Mestre em Tecnologia da Informação e atualmente cursa a segunda graduação em Engenharia de Software. Com 14 anos de experiência escrevendo sobre GNU/Linux, Software Livre e Código Aberto, dedica-se a descomplicar o universo tecnológico para entusiastas e profissionais. Seu foco é em notícias, tutoriais e análises aprofundadas, promovendo o conhecimento e a liberdade digital no Brasil.