The encoder an EFB copy to RAM runs is built with rslc's builder instead
of printed as text and parsed again. Built and printed stages compile to
the same SPIR-V and DXBC words for each of the 14 copy formats, with and
without geometry shaders and a reversed depth range; for OpenGL, the
same 56 at GLSL 4.50, 3.30, ES 3.10 and ES 3.20 compile in
glslangValidator. The text encoder goes.
The pixel ubershader is built with rslc's builder instead of printed as
text and parsed again, on every backend. Built and printed stages
compile to the same SPIR-V and DXBC words: each of the 108 uids with 30
random host configs, on Vulkan with and without subgroup reduction and
on D3D. For OpenGL, where framebuffer fetch blends and logic-ops in the
shader, each stage a GLSL 4.50, 3.30, ES 3.10 or ES 3.20 context can be
asked for compiles in glslangValidator.
Both pixel generators now declare their inputs in one place. The text
the ubershader was the last user of goes: the pixel shaders' common
header, the switch trees, the lighting function, the bitfieldExtract
header and the VS_OUTPUT members and their interpolation qualifiers.
OpenGL's pixel shader is built with rslc's builder as the other
backends' are, and the text generator goes. rslc is told what the
context's header said: framebuffer fetch by the EXT or ARM extension,
conservative depth in place of early fragment tests, and subgroup
reductions.
Built for random pixel uids against GLSL 4.50 with subgroups, 3.30 with
conservative depth, and ES 3.10 and 3.20 with either framebuffer fetch,
each stage these contexts can be asked for compiles in glslangValidator.
The pixel shader is built with rslc's builder instead of printed as text
and parsed again, on Vulkan, D3D11, D3D12 and Metal. Built and printed
stages compile to the same SPIR-V and DXBC words: 15,619 random pixel
uids and host configs, with and without subgroup reduction, and every
uid the text refuses the builder refuses too.
The builder's flags say what the text's header said of the device:
subgroup operations, an inverted gl_HelperInvocation and subgroup
operations broken by discard. Vulkan and Metal pass them; Metal builds
at MSL 2.3, as its text compiles.
OpenGL still prints the stage as text until rslc prints framebuffer
fetch, conservative depth and subgroups in GLSL.
The vertex ubershader is built through rslc's builder, as the
specialized vertex shader already is, so no GLSL is generated or
parsed for it on the compile workers.
The lighting function and the per-channel vertex lighting it shares
with the pixel ubershader, and bitfieldExtract for backends without it,
are builder pieces of their own. The text writers nothing uses any
more go: the vertex ubershader's, the line and point expansion, the
line offset, dolphin_isnan's and the output member assignment.
Metal's built shaders now get the same MSL header and fixups its
parsed ones do, so the ubershader lighting loop stays unrolled.
Built stages compile to the same words the text did for Vulkan and
D3D for every texgen count across random host configurations.
The specialized vertex shader is built through rslc's builder instead
of written as GLSL for each backend to parse back: Vulkan gets SPIR-V,
D3D its bytecode and OpenGL GLSL straight from the built stage, with no
text generated or parsed on the compile workers.
The pieces the pixel shaders and the ubershaders will build from too
are shared: the vertex uniforms block, dolphin_isnan, the line and
point expansion and the lighting functions. The text generator and the
lighting macros nothing used are gone.
Built stages compile to the same words the text did for Vulkan and
D3D across random uids and host configurations.
The geometry stage moves to the builder, on pieces the vertex and pixel
stages will share: VS_OUTPUT's layout and member copy, struct Light, the
geometry stage's uniforms and the line offset. Every primitive, texgen
count and host configuration compiles to the same SPIR-V and DXBC words
as its GLSL did, but one: under MSAA the GLSL put 'centroid in' inside
the VertexData blocks where the backend reports no binding layout, as
Vulkan and Direct3D 12 do, and rslc refuses that, so no geometry stage
compiled with MSAA there. The built stage marks those members centroid
(or sample) and compiles to what the GLSL with plain 'centroid' would.
The EFB copy to VRAM stages move to the builder: the copy vertex stage,
and the copy pixel stage for every format and for the one that reads
the format from copy_flags, with the stereo mono-depth read and the
depth range the backend has. Each compiles to the same SPIR-V and DXBC
words as its GLSL did; TextureConverterShaderGen writes no GLSL now.
The rest of the framebuffer stages move to the builder: the EFB format
conversion pixel stages (every conversion, with and without multisampling
and sample shading), the texture reinterpret stages between the formats
there is one for, and the EFB restore stage. Each compiles to the same
SPIR-V and DXBC words as its GLSL did; a pair of formats with no
reinterpret stage builds none, as before. FramebufferShaderGen writes no
GLSL now.
A generator can now build its stage through rslc's builder instead of
writing GLSL for the backend to parse: AbstractGfx::CreateShaderFromBuild
takes a build function, and each backend asks rslc for its own
destination from the built stage - SPIR-V for Vulkan, DXBC at the
device's feature level for D3D11 and D3D12, GLSL or GLSL ES at the
context's version for OpenGL, MSL for Metal. VideoCommon/ShaderBuild
carries the per-backend resource layout the shader headers' macros gave,
and builds a stage in the worker's shader arena, again from the start
where the arena has to grow.
The framebuffer utility stages move first: the screen quad, texture
copy, clear and EFB poke vertex stages, the passthrough geometry stages,
and the texture copy, color and multisample resolve pixel stages. Each
compiles to the same SPIR-V and DXBC words as its GLSL did; the text
writers are gone.
rslc prints OpenGL's GLSL without bindings, so the OpenGL backend binds
blocks, samplers, attributes and outputs by name for every program.
Every Statistics counter, the projection copies and the widescreen ratio
averages were only written since the debug UI went; the counters bumped
per primitive, per triangle and per pixel in the software rasterizer.
The widescreen heuristic keeps only the two vertex counts it compares,
from one projection/viewport ratio per flush instead of up to three.
GetCPRegInfo, the CP register describer, has no caller.
An encoder reads the rest of the copy (the EFB's format, depth, YUV,
filter rows, overflow, gamma) from its uniforms, in what was the
block's padding, so one per copy format draws them all. Where copies
to RAM may be made, every format's is built on the workers before the
game starts: a copy to RAM has no other pipeline to draw with. The
gate checks pictures with copies to RAM too, and fails one that waits
for its encoder; the corpus made the parent build 201 on the draw path.
In Async (UberShaders), where ubershaders draw only until the
specialized pipeline is built, their pipelines are keyed sized for 8
texgens, and the pixel shader reads the draw's count from XF's, kept
in the pixel constants' padding (the block and savestates keep their
size). 3 are built before the game starts where there were 27. Over
the corpus, shaders made fall from 134 to 102, their words from 737739
to 274571, pipelines from 182 to 158, and loading from about 1.03 s to
0.22 s on lavapipe, with the same pictures; ubershaders sized so drew
every frame the same too. Synchronous (UberShaders) keeps them sized
for the draw's texgens.
A shader's name labels it for debugging tools as it is made and is not
kept: Vulkan terminates it in a stack buffer, GL and D3D11 pass it with
its length, D3D12 widens it for a compute pipeline alone. The shader
cache names its shaders with literals instead of formatting each uid
on the heap, on the workers.
The stats build counts the cycles generating GX shader text and in
rslc, and the words rslc emits. The gate holds the words against the
baseline and the parent, and reports each state's cycles in text, rslc,
the workers and the driver.
Where the backend sets cull mode, depth, blending and the logic op per
draw, specialized pipelines are kept under the uid as the driver bugs
leave it, without that state and the pixel shader bits the shader does
not read, as ubershader pipelines are; the draws hand their state to the
backend with SetDrawState. The uid cache still records the uids the
draws asked for. Over the corpus, pipelines made fall from 620 to 236,
one per driver pipeline.
With the shader cache on, a shader cache file borrows each new shader's
binary from the shader that owns it (LinearDiskCache::AppendBorrowed)
and writes it from there as it closes, which it does before the shaders
go. A binary is no longer copied into the cache's own buffer.
A disk cache makes room for an entry at the end of what it will write
(LinearDiskCache::AppendBegin), and the backend writes its pipeline data
straight there: GL's program binary from glGetProgramBinary, D3D12's
blob copied once out of the driver's. The Vulkan pipeline cache is built
in place too, vkGetPipelineCacheData writing into the store written to
disk. No vector in between, no copy of it.
The eight format pairs the texture cache reinterprets on the GPU are
built with the shared pipelines, and with GPU texture decoding every
decoding shader, so a texture read in another format, or decoded, never
waits for a compile. The stutter corpus reads some of its copies back in
each pair's other format.
A "Shader Cache" core option, off by default: nothing needs it to play
without stutter, and machines slow to compile shaders can turn it on to
start games sooner. With it on, a cache file keeps what it is handed in
memory and writes it in one write as it closes, so a draw that builds a
shader or pipeline no longer writes to the disk.
The stutter gate runs cold with the cache off, and fills it with a run
before the recipes and warm runs, which have it on.
The EFB copy pixel shader reads the copy's filter rows, overflow,
gamma, alpha, depth and intensity from its uniforms, each branch taking
the path a shader built for that copy would, so one is built per
format. One more, built with the shared pipelines, reads the format
from them as well and draws a format's copies until the format's own is
built on a worker.
The stutter corpus copies the EFB to a texture in every colour,
intensity and depth format, with the EFB with and without alpha, draws
it back textured, and cycles the copy filter and gamma. Each frame
draws its number, which the harness reads back, so the picture check
compares the two cores frame by frame in both synchronous modes. The
baseline is the new corpus's.
Where the backend sets cull mode, depth, blending and the logic op per
draw (BackendInfo::uDrawState*Bits), ubershader pipelines are kept under
the uid as the driver bugs leave it, without that state and without the
pixel shader bits the shader does not read. The vertex manager hands
the draw's state to the backend with AbstractGfx::SetDrawState. On
Vulkan, every state a draw is in finds the pipeline built before the
game started.
With ubershaders, every ubershader pipeline there can be is built
before the game starts, on the precompile threads, so a draw never
waits for the driver to compile one. A reload waits for them again.
Where the device sets the logic op per draw, its mode is no longer part
of a pipeline, so one ubershader pipeline with integer output draws
every mode. The precompile also builds the logic op pipelines with
dual-source output asked for, as BlendingState::Generate leaves it.
The stats build counts the pipelines the driver compiles or links, and
those a draw waits for.
make STATS=1 builds parallel_gx1_libretro_stats with counters for each
kind of draw-path compile, wait and cache write, worker compiles, and
every shader and pipeline made; release builds have none. Tools/stutter
generates a synthetic FIFO corpus, runs it in the four cache states,
times parent and candidate ABBA, compares pictures, and gates the
counters against baseline.txt and the parent.
A draw that changes its pipeline finds it with one hash of the uid and a
compare, where a map walked down comparing whole uids. The tables, in C,
hold each uid's shader or pipeline and whether it is compiling, and the
shader cache deletes what they hold.
The shader cache keeps its compile items in chunks and reuses them, so a
shader or pipeline compiled while the game runs allocates nothing. Each
item embeds the compiler's link and callbacks, so a finished one is pushed
back as it is, and a pipeline waiting on its stages queues itself again.
The compiler keeps the waiting items in a heap by priority and order, and
is a member of the shader cache rather than an object of its own.
A backend is handed the ShaderCode: Vulkan and D3D write their header
into the room kept in front of the text and compile the two as one span,
and GL hands the header, any prefix and the text to the driver as they
are and keeps the text's block for its link messages.
ShaderText is one growing block of chars with room kept in front for a
header. ShaderCode writes into it as it is or printf-style, without fmt
or std::string; the generators' string parameters, tables and switch
trees are plain C strings, and the UID enumerations fill arrays.
SPIR-V and DXBC stay in the block rslc returns instead of being copied
into vectors, and the disk cache is lent the code to write. Code read
back from the cache is copied once into a block of its own.
Where the driver compiles on threads of its own
(GL_KHR_parallel_shader_compile or the ARB one), the asynchronous
shader modes on OpenGL compile in the background on the frontend's
context alone: a missing program's compile and link are started, a
couple of work items a frame, and its draws use the ubershaders, or
are skipped, until GL_COMPLETION_STATUS says the link is done; its
link is checked, its variables set and its binary written to the cache
then. A program drawn with before it is done is waited for there. A
software rasterizer, which compiles when it first draws, compiles on
the spot as before.
The shader compiler gets a deferred mode for it, without threads,
compiling the items waiting a few at a time, and AbstractPipeline tells
whether a pipeline's compile is still running and whether it can be
drawn with. With the driver's threads alone, every ubershader pipeline
there can be is not built in the background.
Shader compilation defaults to Async (UberShaders): a draw whose own
pipeline is not built yet is drawn with an ubershader one, exact
rendering, while its own builds on the compiler threads, which now
number as many as the machine has to spare (cores - 3, 1 to 4) instead
of one.
What is left to stutter is an ubershader pipeline itself, built on the
spot the first time a draw needs one: one per vertex layout and fixed
function state. Every ubershader pipeline a draw uses is now recorded,
in <game id>.uberuidcache next to the specialized UID cache, and those
are built before the game starts the next time it boots; every other
ubershader pipeline there can be, and the specialized pipelines known,
build in the background while it runs instead of before it starts,
which took 21 s on lavapipe. The record is written when the cache
closes, into room reserved when it opens, so recording allocates
nothing in the middle of a game.
Without compiler threads (OpenGL here, with no shared context for
them), asking for a pipeline in the background builds it on the spot
and an ubershader one besides: the asynchronous modes draw as
Synchronous does then, and nothing extra is built before the game
starts.
Booting a FIFO log no longer hangs: the CPU thread clears the EFB, which
waits on the GPU, before it reaches its run loop, and the frontend's
thread waited for that run loop without running the GPU. It runs the
GPU until then.
Nothing ever made one: every backend was handed a null includer, and the
OpenGL backend's #include resolver returned the source untouched. The
parameter goes from CreateShaderFromSource and everything beneath it,
and ShaderCompileUtils with it.
Nothing is drawn over the game any more. The OSD message queue, the
ImGui overlay that drew it (with the shader-compile progress window and
the statistics, projection and scissor windows), and the imgui and implot
libraries are removed from the build.
Core::DisplayMessage now writes to the log, and the former OSD calls
go through it. Shader compilation no longer presents frames outside
retro_run while it waits.
Deleted with it: the "OSD enabled" core option, the OSD, FPS, speed,
graph, statistics and internal-resolution display settings, and the
ImGui shaders and texture conversion.
Both fed user-written GLSL to the backends at runtime, which the move to
bytecode emitted straight from the shader generators leaves no compiler
for. The frontend's own shader pipeline covers post-processing.
The presentation pass keeps a plain copy and the built-in correction
shader for output resampling, colour space and gamma correction and HDR
scaling, now compiled in rather than loaded from Sys/Shaders. The
graphics-mod system keeps its draw, EFB, projection and texture actions;
custom pipelines, materials, shader, mesh and sampler assets, the custom
constant buffers in every backend and the two mods built on them are
gone, along with the shader generators' custom-shader hooks.
Queue newly discovered GX pipeline UIDs during rendering and append them when the cache closes on reload or shutdown. Keep the existing immediate writes for standalone Dolphin.
Accomplished using `run-clang-tidy` with `performance-move-const-arg,performance-unnecessary-value-param,modernize-pass-by-value`.
Changed arguments to const references, removed them where inappropriate (e.g. sink parameters). Same with std::move.
Manually reviewed each change to make sure that it makes sense, and do something more appropriate if possible.
LibretroAdmin