From: vkd3d-proton contributor <[email protected]>
Date: Sun, 17 May 2026 19:10:00 +0200
Subject: [PATCH] vkd3d: Track and report VK_EXT_descriptor_heap embedded
 sampler budget usage.

The Vulkan VK_EXT_descriptor_heap extension imposes a per-device cap on
the total number of pEmbeddedSampler references that may be attached to
pipelines created via VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, via
VkPhysicalDeviceDescriptorHeapPropertiesEXT::maxDescriptorHeapEmbeddedSamplers.

In practice this budget is small on some hardware (NVIDIA Ampere = 2032)
and very large on others.  UE5 + Streamline titles (Hellblade 2 confirmed,
appid 2461850) compile enough pipeline permutations during Settings ->
Graphics to push the cumulative count past the budget on Ampere.  Past
that point, the NVIDIA proprietary driver returns VK_SUCCESS from
vkCreate{Graphics,Compute}Pipelines but produces malformed pipelines whose
first draw faults at VA 0 (XID 31, FAULT_PDE ACCESS_TYPE_VIRT_READ on
GPC1/GPCCLIENT_GCC), losing the device.  The same workload runs cleanly on
Ada (RTX 40-series) which advertises a much larger budget.

This change is diagnostics-only: add a per-device cumulative counter of
pEmbeddedSampler references seen at every VK_PIPELINE_CREATE_2_
DESCRIPTOR_HEAP_BIT_EXT pipeline creation, and emit one log line per
threshold crossing (50% / 75% / 90% / 100% / 110% / 125% of the budget).
That makes it possible to confirm from a single PROTON_LOG whether a
crash was preceded by exhaustion of this budget, without imposing any
runtime behaviour change for unaffected workloads.

Hooked at: compute / graphics / linked graphics pipeline creates
(state.c), ray-tracing pipeline creates (raytracing_pipeline.c) and
work-graph pipeline creates (workgraphs.c).  The accounting helper walks
the mapping pNext chain itself, so call sites pass either the mapping
struct directly or a stage's pNext chain.
---
 libs/vkd3d/device.c              | 94 ++++++++++++++++++++++++++++++++
 libs/vkd3d/raytracing_pipeline.c |  7 +++
 libs/vkd3d/state.c               |  9 +++
 libs/vkd3d/vkd3d_private.h       | 13 +++++
 libs/vkd3d/workgraphs.c          |  4 ++
 5 files changed, 127 insertions(+)

diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c
index d514f6d0..5829229e 100644
--- a/libs/vkd3d/device.c
+++ b/libs/vkd3d/device.c
@@ -9547,6 +9547,100 @@ uint32_t d3d12_device_get_max_descriptor_heap_size(struct d3d12_device *device,
     }
 }

+static uint32_t d3d12_device_count_embedded_samplers(
+        const VkShaderDescriptorSetAndBindingMappingInfoEXT *info)
+{
+    uint32_t i, count = 0;
+
+    if (!info)
+        return 0;
+
+    for (i = 0; i < info->mappingCount; ++i)
+    {
+        const VkDescriptorSetAndBindingMappingEXT *mapping = &info->pMappings[i];
+
+        switch (mapping->source)
+        {
+            case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT:
+                if (mapping->sourceData.constantOffset.pEmbeddedSampler)
+                    ++count;
+                break;
+            case VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT:
+                if (mapping->sourceData.pushIndex.pEmbeddedSampler)
+                    ++count;
+                break;
+            default:
+                break;
+        }
+    }
+
+    return count;
+}
+
+void d3d12_device_account_embedded_samplers(struct d3d12_device *device,
+        const void *mapping_info_pnext_chain,
+        const char *kind)
+{
+    /* Thresholds (percent of budget) at which we emit a one-shot log message. */
+    static const uint32_t thresholds_percent[] = { 50, 75, 90, 100, 110, 125 };
+    const VkShaderDescriptorSetAndBindingMappingInfoEXT *mapping_info = NULL;
+    const VkBaseInStructure *pnext;
+    uint32_t budget, added, total, idx, observed;
+
+    if (!device->vk_info.EXT_descriptor_heap)
+        return;
+
+    budget = device->device_info.descriptor_heap_properties.maxDescriptorHeapEmbeddedSamplers;
+    if (!budget)
+        return;
+
+    for (pnext = mapping_info_pnext_chain; pnext; pnext = pnext->pNext)
+    {
+        if (pnext->sType == VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT)
+        {
+            mapping_info = (const VkShaderDescriptorSetAndBindingMappingInfoEXT *)pnext;
+            break;
+        }
+    }
+
+    added = d3d12_device_count_embedded_samplers(mapping_info);
+    if (!added)
+        return;
+
+    total = vkd3d_atomic_uint32_add(&device->embedded_sampler_total, added,
+            vkd3d_memory_order_acq_rel);
+
+    for (;;)
+    {
+        idx = vkd3d_atomic_uint32_load_explicit(&device->embedded_sampler_threshold_idx,
+                vkd3d_memory_order_acquire);
+        if (idx >= ARRAY_SIZE(thresholds_percent))
+            return;
+        if ((uint64_t)total * 100u < (uint64_t)budget * thresholds_percent[idx])
+            return;
+
+        observed = vkd3d_atomic_uint32_compare_exchange(&device->embedded_sampler_threshold_idx,
+                idx, idx + 1u, vkd3d_memory_order_acq_rel, vkd3d_memory_order_acquire);
+        if (observed != idx)
+            continue;
+
+        if (thresholds_percent[idx] < 100u)
+        {
+            WARN("VK_EXT_descriptor_heap embedded-sampler usage at %u%% of budget "
+                    "(%u of %u; +%u this pipeline) [%s].\n",
+                    thresholds_percent[idx], total, budget, added, kind ? kind : "?");
+        }
+        else
+        {
+            ERR("VK_EXT_descriptor_heap embedded-sampler usage at %u%% of budget "
+                    "(%u of %u; +%u this pipeline) [%s].  Past 100%% NVIDIA drivers are "
+                    "known to silently produce malformed pipelines that fault on first "
+                    "draw (XID 31, MMU FAULT_PDE @ VA 0).\n",
+                    thresholds_percent[idx], total, budget, added, kind ? kind : "?");
+        }
+    }
+}
+
 static bool d3d12_device_supports_16bit_shader_ops(struct d3d12_device *device)
 {
     return device->device_info.vulkan_1_2_features.shaderFloat16 &&
diff --git a/libs/vkd3d/raytracing_pipeline.c b/libs/vkd3d/raytracing_pipeline.c
index 2559d356..f93721ba 100644
--- a/libs/vkd3d/raytracing_pipeline.c
+++ b/libs/vkd3d/raytracing_pipeline.c
@@ -2591,6 +2591,13 @@ static HRESULT d3d12_state_object_compile_pipeline_variant(struct d3d12_rt_state
             VK_NULL_HANDLE, 1, &pipeline_create_info, NULL,
             creating_library ? &variant->pipeline_library : &variant->pipeline));

+    if (vr == VK_SUCCESS && d3d12_device_use_descriptor_heap(object->device))
+    {
+        for (i = 0; i < pipeline_create_info.stageCount; ++i)
+            d3d12_device_account_embedded_samplers(object->device,
+                    pipeline_create_info.pStages[i].pNext, "ray-tracing pipeline");
+    }
+
     if (vr == VK_SUCCESS && (object->flags & D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS) &&
             object->type == D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE)
     {
diff --git a/libs/vkd3d/state.c b/libs/vkd3d/state.c
index 13dd23b7..31bbc2e6 100644
--- a/libs/vkd3d/state.c
+++ b/libs/vkd3d/state.c
@@ -3536,6 +3536,9 @@ static HRESULT vkd3d_create_compute_pipeline(struct d3d12_pipeline_state *state,
     vr = VK_CALL(vkCreateComputePipelines(device->vk_device,
             vk_cache, 1, &pipeline_info, NULL, &state->compute.vk_pipeline));

+    if (vr == VK_SUCCESS && d3d12_device_use_descriptor_heap(device))
+        d3d12_device_account_embedded_samplers(device, &state->root_signature->heap.mapping_info, "compute pipeline");
+
     if (vkd3d_queue_timeline_trace_cookie_is_valid(cookie))
     {
         const char *kind;
@@ -6746,6 +6749,9 @@ static VkResult d3d12_pipeline_state_link_pipeline_variant(struct d3d12_pipeline
     vr = VK_CALL(vkCreateGraphicsPipelines(state->device->vk_device,
             vk_cache, 1, &create_info, NULL, vk_pipeline));

+    if (vr == VK_SUCCESS && d3d12_device_use_descriptor_heap(state->device))
+        d3d12_device_account_embedded_samplers(state->device, &state->root_signature->heap.mapping_info, "graphics pipeline (linked)");
+
     if (vkd3d_queue_timeline_trace_cookie_is_valid(cookie))
     {
         const char *kind = vr == VK_SUCCESS ? "LINK OK" : "LINK ERR";
@@ -6963,6 +6969,9 @@ VkPipeline d3d12_pipeline_state_create_pipeline_variant(struct d3d12_pipeline_st

     vr = VK_CALL(vkCreateGraphicsPipelines(device->vk_device, vk_cache, 1, &pipeline_desc, NULL, &vk_pipeline));

+    if (vr == VK_SUCCESS && d3d12_device_use_descriptor_heap(device))
+        d3d12_device_account_embedded_samplers(device, &state->root_signature->heap.mapping_info, "graphics pipeline");
+
     if (vkd3d_queue_timeline_trace_cookie_is_valid(cookie))
     {
         const char *kind;
diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h
index bd9be513..4f1647a4 100644
--- a/libs/vkd3d/vkd3d_private.h
+++ b/libs/vkd3d/vkd3d_private.h
@@ -5811,6 +5811,15 @@ struct d3d12_device
     struct vkd3d_device_swapchain_info swapchain_info;
     struct vkd3d_device_frame_markers frame_markers;

+    /* Cumulative count of pEmbeddedSampler references attached to
+     * VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT pipelines created on this
+     * device, used to detect when we approach
+     * descriptor_heap_properties.maxDescriptorHeapEmbeddedSamplers (the budget
+     * past which NV drivers are known to produce malformed pipelines that
+     * fault at VA 0 on first draw). Diagnostics only. */
+    uint32_t embedded_sampler_total;
+    uint32_t embedded_sampler_threshold_idx;
+
     struct
     {
         struct vkd3d_shader_quirk_info quirks;
@@ -5855,6 +5864,10 @@ VkPipeline d3d12_device_get_or_create_fragment_output_pipeline(struct d3d12_devi

 uint32_t d3d12_device_get_max_descriptor_heap_size(struct d3d12_device *device, D3D12_DESCRIPTOR_HEAP_TYPE heap_type);

+void d3d12_device_account_embedded_samplers(struct d3d12_device *device,
+        const void *mapping_info_pnext_chain,
+        const char *kind);
+
 static inline struct d3d12_device *unsafe_impl_from_ID3D12Device(d3d12_device_iface *iface)
 {
     return CONTAINING_RECORD(iface, struct d3d12_device, ID3D12Device_iface);
diff --git a/libs/vkd3d/workgraphs.c b/libs/vkd3d/workgraphs.c
index ae23737b..de927015 100644
--- a/libs/vkd3d/workgraphs.c
+++ b/libs/vkd3d/workgraphs.c
@@ -1918,6 +1918,7 @@ static HRESULT d3d12_wg_state_object_compile_pipeline(
             ERR("Failed to create pipeline, vr %d\n", vr);
             return hresult_from_vk_result(vr);
         }
+        d3d12_device_account_embedded_samplers(object->device, pipeline_info.stage.pNext, "work-graph pipeline");
     }

     /* CPU node entry, multiple payloads. */
@@ -1939,6 +1940,7 @@ static HRESULT d3d12_wg_state_object_compile_pipeline(
         ERR("Failed to create pipeline, vr %d\n", vr);
         return hresult_from_vk_result(vr);
     }
+    d3d12_device_account_embedded_samplers(object->device, pipeline_info.stage.pNext, "work-graph pipeline");

     /* GPU entry */
     tmp->spec_data[spec_constant_index + SPEC_IS_INDIRECT_BDA_STRIDE] = 1;
@@ -1959,6 +1961,7 @@ static HRESULT d3d12_wg_state_object_compile_pipeline(
         ERR("Failed to create pipeline, vr %d\n", vr);
         return hresult_from_vk_result(vr);
     }
+    d3d12_device_account_embedded_samplers(object->device, pipeline_info.stage.pNext, "work-graph pipeline");

     /* Non-entry node */
     tmp->spec_data[spec_constant_index + SPEC_IS_ENTRY_POINT] = 0;
@@ -1979,6 +1982,7 @@ static HRESULT d3d12_wg_state_object_compile_pipeline(
         ERR("Failed to create pipeline, vr %d\n", vr);
         return hresult_from_vk_result(vr);
     }
+    d3d12_device_account_embedded_samplers(object->device, pipeline_info.stage.pNext, "work-graph pipeline");

     assert(spec_constant_index + (is_broadcast ? SPEC_COUNT_BROADCAST : SPEC_COUNT_NON_BROADCAST) == tmp->spec_data_count);


--
2.46.0