FROM Software - Elden Ring era notório por sutters de compilação de shader no lançamento
Como a GPU de cada PC é diferente, a compilação de shaders é necessária para que os jogos sejam executados em diferentes marcas e modelos de placas gráficas. Infelizmente, esse processo de compilação pode causar stuters irritantes.
Alguns jogos têm um tipo de travamento que ocorre independentemente da potência do computador ou das configurações escolhidas. Isso é causado por um processo conhecido como “compilação de shader” e é um problema crescente em jogos para PC.
O que são shaders?
Shaders são programas de computador que ajudam a determinar vários aspectos dos gráficos renderizados. Pixel shaders, por exemplo, calculam os atributos de um pixel. Isso inclui a cor, brilho, refletividade ou transparência desse pixel. Se você deseja que algo em seu jogo pareça úmido, use um sombreador especial para obter essa aparência, em vez de fazê-lo meticulosamente à mão.
Shaders são o que torna as GPUs modernas tão flexíveis, já que essas GPUs são projetadas para executar qualquer coisa que possa ser expressa na linguagem de programação de shader . Eles substituem a antiga tecnologia de GPU de “pipeline de função fixa”, na qual os tipos de matemática gráfica que uma GPU poderia fazer eram embutidos em seu silício.
O que é a compilação shader?
“Compilação” é um termo de computador que se refere a pegar o código escrito por um programador humano e traduzi-lo em código de máquina que o processador específico destinado a executar o software em questão possa entender. Então, por exemplo, você pode compilar seu código para rodar em uma CPU Intel ou Apple Silicon .
A mesma coisa é necessária para uma GPU. O código do shader deve ser compilado para ser executado na marca e modelo de GPU específicos em questão. Se você alterar a GPU, atualizar seus drivers ou o jogo receber uma atualização, os shaders devem ser compilados novamente.
Por que alguns jogos de PC têm stutter de compilação de shader?
Em alguns jogos, a compilação de shaders em segundo plano interfere no jogo em si, causando travamentos visíveis. O computador está trabalhando muito para compilar os shaders para executar o jogo sem problemas. Alguns desenvolvedores trabalham para otimizar a compilação para que ela tenha pouco ou nenhum impacto no desempenho do jogo, enquanto outros espalham a compilação de shaders por todo o jogo, esperando que o problema seja de curta duração. Nesse caso, você só encontraria os stutters no início de um novo nível ou quando entrar em um novo ambiente que usa shaders que não eram necessários até aquele ponto.
As falhas de compilação têm sido particularmente flagrantes nos jogos Unreal Engine 4, que é um mecanismo de jogo amplamente difundido e popular. Especificamente, esses stutters se tornam um problema ao executar um jogo no DirectX 12. Isso ocorre em parte porque o DirectX 12 muda o funcionamento da compilação de shader, colocando mais controle nas mãos dos desenvolvedores. No entanto, isso também significa que os desenvolvedores podem não ter a melhor maneira de otimizar a compilação de shader usando a versão mais recente e melhor do DirectX.
Por que os consoles não têm stutters de compilação de shader?
Os stutters da compilação de shader é um problema completamente ausente em consoles como o PS5 e o Xbox Series X|S. Isso ocorre simplesmente porque os desenvolvedores sabem exatamente qual hardware está dentro de cada console para que possam pré-compilar todos os shaders; não há necessidade de compilá-los no sistema local porque você já sabe qual GPU está direcionando.
É possível fazer isso no PC, mas como existem tantas GPUs e configurações de sistema, não seria prático. No entanto, no caso do Steam Deck da Valve, a Valve inclui um cache shader pré-compilado com alguns jogos porque, claro, todos os Steam Decks têm a mesma GPU.
O que você pode fazer sobre os stutters de compilação?
Infelizmente, na maioria das vezes, os desenvolvedores precisam corrigir problemas de compilação de shader. A boa notícia é que eles eventualmente entenderão o processo. A Unreal Engine 5.1 pode incluir um recurso automatizado que ajudará os desenvolvedores com o cache sem que o impacto no desempenho seja tão grave.
A lista de coisas que você pode fazer para atenuar os stutters não é longa, mas algumas dessas opções podem ajudar:
- Se um jogo permite pré-compilar shaders, deixe-o. Isso pode demorar um pouco, mas a experiência do jogo será perfeita.
- A menos que uma atualização do jogo inclua uma correção de travamento do shader, espere até terminar de jogar ou os shaders podem ser compilados novamente.
- Aguarde as atualizações do driver da GPU até terminar o jogo atual, caso ele acione a compilação novamente.
- Quando o stutter de compilação começar em um jogo, aperte o botão de pausa e espere até que termine antes de continuar jogando.
- Use o DirectX 11 em vez da versão DirectX 12 de um jogo. Freqüentemente, o stutter de shaders é reduzido ou ausente, embora você desista dos recursos do DX12 na barganha.
- Em vez disso, jogue o jogo em um console.
Com o tempo, esse problema provavelmente desaparecerá ou se tornará muito menos intrusivo. Por exemplo, os desenvolvedores podem descarregar a compilação de shaders em núcleos de CPU de que o jogo não precisa, o que é uma situação comum em PCs modernos com muitos núcleos. Até então, o #stutterstruggle continuará sendo um problema irritante nos jogos para PC.
What Is Shader Compilation and Why Does It Make PC Games Stutter?
Some games have a type of stutter that happens no matter how powerful your computer is, or which settings you choose. This is caused by a process known as “shader compilation,” and it’s a growing issue in PC gaming.
www.howtogeek.com
Explicação mais técnica:
Um pouco de esclarecimento sobre os tempos de compilação de shaders moderno
Então eu vi esses tweets hoje cedo:
Não vou citar todos os tweets, apenas mencionei outro que outros jogos (mais antigos) não têm esse problema.
Portanto, há algumas questões que precisam ser explicadas.
Mundo Pré DX12/Vulkan
Em D3D11/OpenGL, podemos simplificar o pipeline de renderização para o seguinte (não vou cobrir todos os estágios):
- Entrada de vértice: Isso é programável do lado C++. Ele responde a perguntas como:
- O vértice contém apenas posição?
- Tem normais?
- A variável está no formato FLOAT32? Usa float de 16 bits? em 8 bits onde o intervalo [0;255] é convertido para intervalo [0; 1,0]?
- Vertex shader, que finge que todas as entradas de vértice estão em flutuação de 32 bits
- Pixel Shader, que finge que todos os pixels são RGBA de 4 canais em precisão flutuante de 32 bits
- O pixel de saída, que pode ser:
- Em RGBA8_UNORM, RGBA16_UNORM, RGBA16_FLOAT, RG16_UNORM, R8_SNORM, etc. Veja DXGI_FORMAT para uma longa lista.
- Pode usar MSAA, não pode usar MSAA
- Pode usar mistura alfa, não pode
Como as GPUs modernas lidam com esse problema no D3D11/GL? Dividindo ambos os shaders em 3 partes:
- Prefixo ou Preâmbulo
- Corpo
- Sufixo ou Epílogo
O corpo é o shader de vértice/pixel que é compilado por fxc (ou pelo driver OpenGL) e posteriormente convertido em um ISA (Arquitetura de conjunto de instruções) específico da GPU, ou seja, o programa binário que a GPU executará.
O prefixo e o sufixo são regiões passíveis de patches.
O shader de vértice 'finge' que a entrada está em flutuação de 32 bits. Assim, o corpo foi compilado como 32 bits.
Mas se a entrada for, digamos, meio ponto flutuante de 16 bits com um passo de vértice específico (o deslocamento em bytes entre cada vértice), o preâmbulo será corrigido com uma sequência curta de instruções que carregam os meios flutuantes de 16 bits dos deslocamentos corretos e os converte em flutuações de 32 bits que o corpo espera.
O mesmo acontecerá com o shader de pixel, que precisa converter seus quatro floats de 32 bits em, digamos, RG8_UNORM, ou seja, descartar o canal azul e alfa, converter o vermelho e o verde do intervalo [0; 1,0] até o intervalo [0; 255] e guarde-o na memória.
Para fazer isso, o driver corrigirá o epílogo e executará a conversão de 32 bits -> 8 bits nos canais vermelho e verde.
Dependendo da GPU, o sufixo pode conter mais operações relacionadas com MSAA ou mesmo mistura alfa (este último é particularmente verdadeiro em dispositivos móveis)
Os jogos D3D11 executaram otimizações pesadas apenas na seção do corpo , principalmente feitas pelo compilador fxc, e os desenvolvedores podem armazená-los em um único arquivo (um cache) que pode ser distribuído para todas as máquinas.
O driver ainda precisará converter o bytecode D3D11 em um ISA específico da GPU, mas depende das otimizações pesadas do fxc para fazer o trabalho. Assim, a conversão de D3D11 para bytecode não é gratuita, mas também não é muito cara e muitas vezes pode ser ocultada pelo threading do lado do driver.
Shaders podem ser emparelhados arbitrariamente
Mais uma coisa que esqueci de mencionar é que os shaders de vértice e pixel podem ser combinados arbitrariamente em tempo de execução. Existem algumas regras, chamadas de assinaturas, sobre ter layouts correspondentes, caso contrário, os dois shaders não podem ser emparelhados.
Mas, apesar dessas regras, se um shader de vértice gerar 16 flutuadores para o shader de pixel usar, mas o shader de pixel usar apenas 4 deles; o vertex shader não pode ser otimizado para essa suposição.
O corpo do shader de vértice será otimizado como se o shader de pixel consumisse todos os 16 flutuadores. No máximo, o sufixo exportará apenas 4 flutuadores para o pixel shader; mas ainda há muito código desperdiçado no corpo que poderia ser removido, mas não será.
Os drivers podem tentar analisar o par resultante e remover esse desperdício, mas eles têm apenas um tempo limitado para fazer isso (caso contrário, alguns jogos podem apresentar travamentos pesados e permanentes).
Mundo pós-DX12/Vulkan
O DX12/Vk introduziu o conceito de Pipeline State Objects, também conhecido como PSOs, que é uma enorme bolha de todos os dados incorporados em um único objeto API.
Como os PSOs contêm todos os dados necessários, não há mais necessidade de dividir shaders em prefixo, corpo e epílogo.
Os drivers sabem com antecedência o formato do vértice, os shaders de vértice e pixel que serão emparelhados, o formato do pixel, a contagem de MSAA, se a mistura alfa será usada etc.
Temos todas as informações necessárias para produzir o shader ideal:
- Os caminhos de código que produzem saída não utilizada serão removidos
- Todo o 'corpo' do shader pode preferir usar registradores flutuantes de 16 bits se a entrada do formato de vértice estiver em 16 bits (em vez de converter 16 -> 32 bits e, em seguida, operar em 32 bits)
- As instruções de carregamento e armazenamento podem ser reordenadas em qualquer lugar para reduzir a latência (que normalmente seria forçada para o prefixo ou sufixo)
Portanto , a maioria das otimizações é atrasada até o momento real de criação do PSO. Ao contrário do fxc do D3D11, que demorou uma eternidade para compilar, o compilador dxc e glslang do D3D12 mais recente (se você não estiver usando o compilador da Microsoft) realmente compila muito rápido.
Esses compiladores de shaders mal executam otimizações (embora os otimizadores SPIRV ainda existam e possam fazer a diferença em dispositivos móveis).
Infelizmente, o cache de um PSO está vinculado à GPU e à versão do driver. Portanto, algo tão trivial quanto uma atualização de driver pode invalidar o cache, o que significa que você terá que esperar novamente.
Como disse David Clyde, isso desencoraja ativamente as pessoas de atualizar e pode se tornar um problema.
Existem estratégias de mitigação sendo pesquisadas, como:
- Compilar uma versão lenta do shader em pouco tempo e recompilar em segundo plano uma versão otimizada
- Usuários fazendo upload de seus caches para um gigante banco de dados compartilhado classificado por dispositivo GPU, fornecedor e versão do driver; que outros usuários podem baixar (observe que isso pode trazer problemas de segurança, afinal, um shader é um executável)
- Compiladores de otimização mais rápidos
Observe que os exclusivos PS4 portados, como Horizon Zero Dawn e Detroit Become Human, foram projetados para ter o cache PSO distribuído com o binário (porque há apenas duas GPUs para segmentar: PS4 e PS4 Pro), portanto, eles não foram projetados para recompilar duas vezes (lento então versão rápida). Assim, esses jogos gastam 20 minutos no início construindo seu cache PSO.
Portanto, aí está: é por isso que os jogos modernos estão demorando tanto para criar shaders no início e por que isso pode se tornar mais frequente no futuro.
Uma possível solução:
Existe uma configuração da engine, que pelo o que vi no Guru3D, funciona com qualquer jogo Unreal Engine 4:
Use o botão Windows+R e digite %appdata% e dê enter.
Localize a pasta Config em Local > CallistoProtocol > Saved > Config > WindowsNoEditor
Encontre o arquivo Engine.ini, clique com o botão direito nele e selecione “Abrir com”. Escolha Bloco de Notas.
Substitua conforme a localização dos textos:
Código:
[/script/engine.renderersettings]
r.MipMapLODBias=0
r.SSR.Temporal=1
r.TemporalAA.Algorithm=0
r.TemporalAA.R11G11B10History=1
r.TemporalAAFilterSize=0.7
r.TemporalAAPauseCorrect=1
r.TemporalAACatmullRom=1
r.TemporalAACurrentFrameWeight=0.3
r.TemporalAASamples=8
r.TemporalAASharpness=0.7
r.PostProcessAAQuality=6
r.ScreenPercentage=100
r.TemporalAA.Upsampling=1
r.Upscale.Quality=5
r.SceneColorFringe.Max=0
r.SceneColorFringeQuality=0
r.MotionBlur.Max=0
r.LensFlareQuality=0
r.MotionBlurQuality=0
r.Vignette=0
r.Tonemapper.Quality=1
r.Tonemapper.GrainQuantization=0
r.TonemapperGamma=0
r.TessellationAdaptivePixelsPerTriangle=64
r.DefaultFeature.LensFlare=0
r.TriangleOrderOptimization=1
r.Shaders.Optimize=1
r.OptimizeForUAVPerformance=1
r.AOAsyncBuildQueue=1
r.AOComputeShaderNormalCalculation=1
r.MaxAnisotropy=16
r.VirtualTexture=1
r.FastVRam.BokehDOF=1
r.FastVRam.CircleDOF=1
r.FastVRam.CombineLUTs=1
r.FastVRam.Distortion=1
r.FastVRam.HZB=1
r.FastVRam.Histogram=1
r.FastVRam.SSR=1
r.FastVRam.ShadowPointLight=1
r.FastVRam.Tonemap=1
r.FastVRam.Upscale=1
r.DX11NVAfterMathEnabled=0
D3D12.PSO.DiskCache=1
D3D12.PSO.DriverOptimizedDiskCache=1
D3D11.AFRSyncTemporalResources=1
D3D11.AFRUseFramePacing=1
D3D11.AdjustTexturePoolSizeBasedOnBudget=1
D3D11.AsyncDeferredDeletion=1
D3D11.ForceThirtyHz=0
D3D11.InsertOuterOcclusionQuery=1
D3D11.ResidencyManagement=1
D3D11.StablePowerState=0
D3D11.SyncWithDWM=1
D3D11.TexturePoolOnlyAccountStreamableTexture=1
D3D11.UseUpdateTexture3DComputeShader=1
D3D11.ZeroBufferSizeInMB=32
D3D12.AFRSyncTemporalResources=1
D3D12.AFRUseFramePacing=1
D3D12.AsyncDeferredDeletion=1
D3D12.ForceThirtyHz=0
D3D12.InsertOuterOcclusionQuery=1
D3D12.ResidencyManagement=1
D3D12.ResidencyManagement=1
D3D12.StablePowerState=0
D3D12.StablePowerState=0
D3D12.SyncWithDWM=1
D3D12.SyncWithDWM=1
D3D12.TexturePoolOnlyAccountStreamableTexture=1
D3D12.UseUpdateTexture3DComputeShader=1
D3D12.UseUpdateTexture3DComputeShader=0
D3D12.ZeroBufferSizeInMB=32
D3D12.ZeroBufferSizeInMB=128
D3D12.MaximumFrameLatency=0
r.ShaderPipelineCache.PreOptimizeEnabled=1
r.ShaderPipelineCache.SaveUserCache=1
r.ShaderPipelines=1
r.Shaders.ZeroInitialise=1
r.Shadow.CachePreshadow=1
r.Shadow.CacheWPOPrimitives=1
r.SceneRenderTargetResizeMethod=2
r.SceneRenderTargetResizeMethodForceOverride=1
r.ShaderComplexity.CacheShaders=1
r.ShaderPipelineCache.StartupMode=3
r.ShaderPipelineCache.Enabled=1
r.ShaderPipelineCache.LogPSO=1
r.ShaderPipelineCache.SaveBoundPSOLog=1
r.ShaderPipelineCache.ReportPSO=1
r.ShaderPipelineCache.GameFileMaskEnabled=1
r.ShaderPipelineCache.LazyLoadShadersWhenPSOCacheIsPresent=1
r.ShaderPipelineCache.BatchSize=10
r.Vulkan.PipelineCacheFromShaderPipelineCache=1
r.D3D.ForceDXC=1
r.GTSyncType=1
niagara.CreateShadersOnLoad=1
r.ShaderPipelineCache.AlwaysGenerateOSCache=0
r.XGEShaderCompile=1
r.XGEShaderCompile.Mode=1
r.XGEShaderCompile.Xml.BatchGroupSize=256
r.XGEShaderCompile.Xml.BatchSize=16
r.XGEShaderCompile.Xml.JobTimeout=0.500000
r.RHICmdAsyncRHIThreadDispatch=1
r.RHICmdBalanceParallelLists=2
r.RHICmdBalanceTranslatesAfterTasks=1
r.RHICmdBasePassDeferredContexts=1
r.RHICmdCollectRHIThreadStatsFromHighLevel=0
r.RHICmdDeferSkeletalLockAndFillToRHIThread=1
r.RHICmdPrePassDeferredContexts=1
r.RHICmdShadowDeferredContexts=1
r.RHICmdSpewParallelListBalance=0
r.RHICmdTranslucencyPassDeferredContexts=1
r.RHICmdUseDeferredContexts=1
r.RHICmdUseParallelAlgorithms=1
r.RHICmdVelocityPassDeferredContexts=1
r.RHICmdUseThread=1
r.RHICmdWidth=12
r.ParallelRendering=1
r.ParallelShadows=1
r.ParallelTranslucency=1
r.ParallelVelocity=1
r.SkeletalMeshLODBias=-2
r.HighQualityLightMaps=1
r.CreateShadersOnLoad=1
r.HZBOcclusion=0
r.AllowOcclusionQueries=1
[/script/engine.engine]
FrameRateLimit=144.000000
bEnableMouseSmoothing=False
r.OneFrameThreadLag=0
bAllowMultiThreadedShaderCompile=true
[ConsoleVariables]
AllowAsyncRenderThreadUpdates=1
AllowAsyncRenderThreadUpdates=1
AllowAsyncRenderThreadUpdatesDuringGamethreadUpdates=1
AllowAsyncRenderThreadUpdatesDuringGamethreadUpdates=1
AllowAsyncRenderThreadUpdatesEditor=1
AllowAsyncRenderThreadUpdatesEditor=1
s.AsyncLoadingThreadEnabled=True
[TextureStreaming]
r.Streaming.Boost=1
r.Streaming.FullyLoadUsedTextures=1
r.Streaming.HLODStrategy=2
r.bForceCPUAccessToGPUSkinVerts=True
r.Streaming.FramesForFullUpdate=1
r.Streaming.UseBackgroundThreadPool=1
r.Cache.UpdateEveryFrame=1
r.Streaming.DropMips=0
r.Streaming.LimitPoolSizeToVRAM=0
r.Streaming.MaxTempMemoryAllowed=1024
r.Streaming.MinMipForSplitRequest=0
r.Streaming.HiddenPrimitiveScale=1
r.DetailMode=3
r.LODFadeTime=0.2
r.Streaming.MipBias=0
r.Streaming.UseAllMips=1
r.Streaming.UseMaterialData=1
r.Streaming.UseNewMetrics=1
r.Streaming.UsePerTextureBias=1
r.Shaders.Optimize=1
r.Shaders.FastMath=1
r.UseShaderCaching=1
r.UseShaderPredraw=1
FX.AllowGPUParticles=1
FX.AllowAsyncTick=1
FX.EarlyScheduleAsync=1
r.ForceAllCoresForShaderCompiling=1
FX.BatchAsync=1
FX.BatchAsyncBatchSize=1
r.Emitter.FastPoolEnable=1
FX.AllowGPUSorting=1
FX.AllowCulling=0
GeometryCache.InterpolateFrames=1
GeometryCache.OffloadUpdate=1
r.UseAsyncShaderPrecompilation=1
r.AmbientOcclusion.AsyncComputeBudget=1
r.HZB.BuildUseCompute=1
r.MultithreadedLightmapEncode=1
r.MultithreadedShadowmapEncode=1
r.RDG.AsyncCompute=1
RHI.MaximumFrameLatency=3
r.TargetPrecompileFrameTime=2.00
r.PredrawBatchTime=13
r.AccelPredrawBatchTime=0
r.AccelTargetPrecompileFrameTime=0
r.Streaming.DefragDynamicBounds=1
s.AsyncLoadingThreadEnabled=True
r.Streaming.PoolSize=0
r.VirtualTextures=1
r.Streaming.AmortizeCPUToGPUCopy=1
r.Streaming.MaxNumTexturesToStreamPerFrame=3
r.Streaming.NumStaticComponentsProcessedPerFrame=3
s.AsyncLoadingThreadEnabled=1
s.AsyncLoadingTimeLimit=2.0
s.LevelStreamingActorsUpdateTimeLimit=1.00
s.UnregisterComponentsTimeLimit=0.00
s.AsyncLoadingUseFullTimeLimit=0
s.ContinuouslyIncrementalGCWhileLevelsPendingPurge=1
s.PriorityAsyncLoadingExtraTime=10.00
s.IoDispatcherCacheSizeMB=2048
s.LevelStreamingComponentsRegistrationGranularity=1
s.LevelStreamingComponentsUnregistrationGranularity=1
s.MaxIncomingRequestsToStall=100
s.MaxReadyRequestsToStallMB=0
s.MinBulkDataSizeForAsyncLoading=1000
We need to talk about UE4 Shader compilation issues
Unreal Engine 5.1 detailed, will attempt to fix shader compilation stutters (dsogaming.com)
forums.guru3d.com
Última edição:
