core/d3d11: consume the pre-baked batch FS DXBC blobs
Wires the D3D11 backend to the shared D3DCommon::EmbeddedShaders
pickers extracted in the previous commit. GetBatchPixelShader's
slow path now forks on the pre-baked vs runtime-compiled axes:
Pre-baked path (texture_mode == Disabled OR
filter == Nearest with a non-Disabled texture):
1. Compute use_dual_source from the same shadergen formula the
D3D12 backend uses (and the same one the picker tables
expect).
2. Call the shared picker:
D3DCommon::EmbeddedShaders::PickBatchUntexturedFS or
PickBatchTexturedNearestFS. Returns a Bytecode { data, size }.
3. D3D11::ShaderCompiler::CreatePixelShader(device, data, size)
wraps ID3D11Device::CreatePixelShader and produces the
ID3D11PixelShader directly. No shadergen, no D3DCompile, no
m_shader_cache lookup, no disk cache writeback.
Runtime path (Bilinear / BilinearBinAlpha / JINC2 / JINC2BinAlpha /
xBR / xBRBinAlpha):
Unchanged: per-call shadergen + GenerateBatchFragmentShader +
m_shader_cache.GetPixelShader, exactly the same flow that
covers every cell pre-this-commit.
Both paths converge on a `fresh` ComPtr<ID3D11PixelShader> that
the publish step (mutex + canonical_slot fill + fastpath store +
Reserved-dedup alias fill) consumes identically.
The pre-baked path skips the shader-cache disk-backed entries for
those cells. The D3D11 shader cache is a sourcecode-hash -> DXBC
mapping; the picker bypasses both the source string and the
D3DCompile step, so there's no on-disk entry to write and no
hash to look up. On first launch with no cache, this is what
makes the difference - cold-start CompileShaders / lazy-fault
times drop on every (untextured) and (textured Nearest) cell
they touch. With a warm disk cache the speedup is smaller but
still real (no D3DCompile or shader-cache mutex contention).
The D3D11 batch-shader matrix is 5-dim
([filter][render_mode][texture_mode][dithering][interlacing])
where the [dithering][interlacing] dims hold pre-existing
post-cbuffer-routing redundancy: each (dithering, interlacing)
slot now contains a ComPtr to the same ID3D11PixelShader as the
opposite slot. That waste exists pre-this-commit; we don't shrink
the matrix here because it would touch many call sites and is a
separable cleanup. The pre-baked path inherits the same redundancy
- 4 matrix slots get filled with the same ID3D11PixelShader for
each pre-baked variant - but the additional CreatePixelShader
calls are cheap (no compile, just a refcounted device object) so
the cost is sub-millisecond per slot.
What changes:
src/core/gpu_hw_d3d11.cpp
1. New include: common/d3d_common/embedded_shaders.h.
2. GetBatchPixelShader's slow path restructured. The previous
shadergen + D3DCompile body is preserved verbatim inside
the new `else` branch (the runtime / non-pre-baked path).
Two new `if` arms cover the pre-baked path with shared
picker calls + CreatePixelShader. The publish step (mutex
acquire, canonical_slot fill, fastpath atomic store,
Reserved-dedup alias) is unchanged - it operates on the
same ComPtr<ID3D11PixelShader> regardless of how `fresh`
was produced.
3. use_dual_source bool computed once at the top of the slow
path. Same formula the D3D12 caller uses
(m_supports_dual_source_blend AND ((render_mode is
transparent) OR filter != Nearest)). Same bit the pickers
index on, same bit any future PSO blend-state branching
would need to consult.
What doesn't change:
- HLSL sources, .inc blob bytes, regen tool, shader-cache
disk format. None touched.
- D3D12 runtime behaviour. The shared pickers are still called
from gpu_hw_d3d12.cpp as well (the 9cc64ef commit hooked
them up); both backends now consume the same byte stream.
- precompile_sync / PrecompileBatchShaders on D3D11.
GetBatchPixelShader still gets called for every reachable
cell at precompile time - the matrix still needs to fill so
the per-PSO-build fast path hits later. The fill just runs
faster on the pre-baked cells (no D3DCompile cost). The
progress count is unchanged.
- Visual output. fxc emits ps_5_0 DXBC bytecode that
D3D11::CreatePixelShader and the runtime-D3DCompile path
produce identically from the same HLSL source (the shadergen
output is byte-for-byte the same across API_D3D11 / API_D3D12
macros for the batch FS body, see shadergen.cpp:130-131 and
the audit notes in the d3d_common move commit). Pixel diff:
zero.
Behavioural change for users (D3D11 default settings):
- PSX content runs with texture_filter=Nearest by default. The
typical Palette4Bit Nearest cells are the hot ones; first
draw of each new (render_mode, texture_mode) combo hits the
pre-baked picker + CreatePixelShader rather than shadergen +
D3DCompile. Cold-launch shader-compile latency drops
proportionally.
- On systems with no on-disk shader cache (first launch, cache
wipe, switch to a new RetroArch install): the (untextured)
and (textured Nearest) cells skip the slowest part of the
pre-pipeline-build cost entirely.
- With a warm shader cache, the pre-baked path still saves the
cache mutex acquire + hash compute + disk read for those
cells. Smaller win but consistent.
- Disk cache footprint shrinks: 84 (12 untextured + 72 textured
Nearest) entries no longer get written. Existing entries from
previous versions remain - they hit but produce
bit-identical-or-equivalent ID3D11PixelShader objects when
consumed; over time the user's cache shrinks as
invalidations turn over.
Test:
- g++ -std=c++17 syntax check on the new slow-path block using
a shim TU (ComPtr / ID3D11Device / ID3D11PixelShader / enum
stand-ins + the real embedded_shaders.h) compiles cleanly.
Both pre-baked picker calls and the runtime else-branch
coexist correctly.
- The shared pickers' tables (D3DCommon::EmbeddedShaders
{Untextured, TexturedNearest}FS in
src/common/d3d_common/embedded_shaders.cpp) are validated
by the existing D3D12 path, exercised in
src/core/gpu_hw_d3d12.cpp's GetBatchPipeline. The D3D11
consumer hits the same tables.
Cumulative pre-bake variant count progress, both backends:
Pre-arc: 75 264 (every axis -D)
Post-cbuffer-routing arc: 1 176
Post-c01f8ae / a7f5717 (D3D12 untextured +
Nearest live): 84 baked
Post-this-commit (D3D11 untextured +
Nearest also consume the 84 baked blobs): 168 cell-equivalents
Remaining filters (Bilinear / JINC2 / xBR):
3 templates x ~144 variants. Each template's foundation +
activation pair lands D3D12 first; D3D11 picks up the new
pickers as they land in D3DCommon::EmbeddedShaders.
Next:
- Pre-bake the Bilinear filter slice. Foundation + activation
pair on D3D12; the activation commit also extends D3D11's
GetBatchPixelShader fork to consume the new picker (it's a
one-line `else if (filter == Bilinear || filter ==
BilinearBinAlpha)` next to the existing Nearest arm).
- Same shape for JINC2 / xBR. After the 4th template lands,
the D3D11 slow path's runtime else-branch is unreachable
and can be deleted along with the dim-cache redundancy
cleanup.
This commit is contained in:
parent
36b785aadf
commit
74b28befe3
1 changed files with 69 additions and 16 deletions
|
|
@ -1,5 +1,6 @@
|
|||
#include "gpu_hw_d3d11.h"
|
||||
#include "common/d3d11/shader_compiler.h"
|
||||
#include "common/d3d_common/embedded_shaders.h"
|
||||
#include "common/display.hlsl.h"
|
||||
#include "common/log.h"
|
||||
#include "common/state_wrapper.h"
|
||||
|
|
@ -1337,22 +1338,74 @@ ID3D11PixelShader* GPU_HW_D3D11::GetBatchPixelShader(GPUTextureFilter filter, ui
|
|||
// the loser's ComPtr is released when it falls out of scope
|
||||
// below.
|
||||
//
|
||||
// Construct a per-call shadergen bound to the requested filter
|
||||
// rather than reusing m_shadergen (which is pinned to the
|
||||
// runtime-current m_texture_filtering for the non-batch helpers).
|
||||
// Filter is the only setting that differs between this shadergen
|
||||
// and m_shadergen - all other inputs come from member state that
|
||||
// is single-valued per session. Construction is a handful of POD
|
||||
// copies; the expensive work is GenerateBatchFragmentShader +
|
||||
// D3DCompile + CreatePixelShader that follow, all unchanged from
|
||||
// the pre-dim-cache path.
|
||||
GPU_HW_ShaderGen tmp_shadergen(
|
||||
m_host_display->GetRenderAPI(), m_resolution_scale, m_multisamples, m_per_sample_shading, m_true_color,
|
||||
m_scaled_dithering, filter, m_using_uv_limits, m_pgxp_depth_buffer, m_disable_color_perspective,
|
||||
m_supports_dual_source_blend);
|
||||
const std::string ps = tmp_shadergen.GenerateBatchFragmentShader(
|
||||
static_cast<BatchRenderMode>(render_mode), static_cast<GPUTextureMode>(lookup_mode), dithering, interlacing);
|
||||
ComPtr<ID3D11PixelShader> fresh = m_shader_cache.GetPixelShader(m_device.Get(), ps);
|
||||
// Two paths converge on the same `fresh` ComPtr:
|
||||
// 1. Pre-baked (texture_mode == Disabled OR
|
||||
// filter == Nearest with a non-Disabled texture_mode): no
|
||||
// shadergen, no D3DCompile, no m_shader_cache lookup. The
|
||||
// shared picker in D3DCommon::EmbeddedShaders returns the
|
||||
// matching .inc-supplied DXBC blob and we hand it straight
|
||||
// to D3D11::ShaderCompiler::CreatePixelShader (which wraps
|
||||
// ID3D11Device::CreatePixelShader with the byte / size pair).
|
||||
// Same blobs the D3D12 backend consumes; fxc emits ps_5_0
|
||||
// that both APIs honour identically. No shader-cache
|
||||
// entries are produced for these cells.
|
||||
// 2. Runtime (every other filter): the existing shadergen +
|
||||
// D3DCompile + m_shader_cache path, unchanged. Bilinear /
|
||||
// JINC2 / xBR (and their *BinAlpha variants) still take
|
||||
// this path. As subsequent pre-bake commits land their
|
||||
// filter slices for the D3D12 backend, the same pre-baked
|
||||
// blobs become reusable here.
|
||||
//
|
||||
// The use_dual_source bit is the same shadergen formula the
|
||||
// pickers consume on D3D12 (m_supports_dual_source_blend AND
|
||||
// (transparent render_mode OR non-Nearest filter)). Computed
|
||||
// once at the call site so the pre-baked picker and any future
|
||||
// PSO blend-state branching see the same value.
|
||||
const bool use_dual_source =
|
||||
m_supports_dual_source_blend &&
|
||||
((render_mode != static_cast<uint8_t>(BatchRenderMode::TransparencyDisabled) &&
|
||||
render_mode != static_cast<uint8_t>(BatchRenderMode::OnlyOpaque)) ||
|
||||
filter != GPUTextureFilter::Nearest);
|
||||
const bool untextured =
|
||||
(static_cast<GPUTextureMode>(lookup_mode) == GPUTextureMode::Disabled);
|
||||
const bool textured_nearest =
|
||||
!untextured && (filter == GPUTextureFilter::Nearest);
|
||||
|
||||
ComPtr<ID3D11PixelShader> fresh;
|
||||
if (untextured)
|
||||
{
|
||||
const auto bc = D3DCommon::EmbeddedShaders::PickBatchUntexturedFS(
|
||||
use_dual_source, m_multisamples, m_per_sample_shading,
|
||||
m_disable_color_perspective);
|
||||
fresh = D3D11::ShaderCompiler::CreatePixelShader(m_device.Get(), bc.data, bc.size);
|
||||
}
|
||||
else if (textured_nearest)
|
||||
{
|
||||
const auto bc = D3DCommon::EmbeddedShaders::PickBatchTexturedNearestFS(
|
||||
lookup_mode, use_dual_source, m_multisamples, m_per_sample_shading,
|
||||
m_disable_color_perspective);
|
||||
fresh = D3D11::ShaderCompiler::CreatePixelShader(m_device.Get(), bc.data, bc.size);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Construct a per-call shadergen bound to the requested filter
|
||||
// rather than reusing m_shadergen (which is pinned to the
|
||||
// runtime-current m_texture_filtering for the non-batch helpers).
|
||||
// Filter is the only setting that differs between this shadergen
|
||||
// and m_shadergen - all other inputs come from member state that
|
||||
// is single-valued per session. Construction is a handful of POD
|
||||
// copies; the expensive work is GenerateBatchFragmentShader +
|
||||
// D3DCompile + CreatePixelShader that follow, all unchanged from
|
||||
// the pre-dim-cache path.
|
||||
GPU_HW_ShaderGen tmp_shadergen(
|
||||
m_host_display->GetRenderAPI(), m_resolution_scale, m_multisamples, m_per_sample_shading, m_true_color,
|
||||
m_scaled_dithering, filter, m_using_uv_limits, m_pgxp_depth_buffer, m_disable_color_perspective,
|
||||
m_supports_dual_source_blend);
|
||||
const std::string ps = tmp_shadergen.GenerateBatchFragmentShader(
|
||||
static_cast<BatchRenderMode>(render_mode), static_cast<GPUTextureMode>(lookup_mode), dithering, interlacing);
|
||||
fresh = m_shader_cache.GetPixelShader(m_device.Get(), ps);
|
||||
}
|
||||
|
||||
if (!fresh)
|
||||
{
|
||||
Log_ErrorPrintf("Lazy batch pixel shader compile failed for (f=%u, rm=%u, tm=%u, d=%u, i=%u)",
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue