[PATCH v4 1/4] vkd3d: Call vkInvalidateMappedMemoryRanges() when a mapping is requested on a mapped heap.

[Conor McCarthy]

From: Conor McCarthy

---
 libs/vkd3d/resource.c | 58 ++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 52 insertions(+), 6 deletions(-)

diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c
index 8c050cfe..8561e9c7 100644
--- a/libs/vkd3d/resource.c
+++ b/libs/vkd3d/resource.c
@@ -437,8 +437,28 @@ struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface)
     return impl_from_ID3D12Heap(iface);
 }

-static HRESULT d3d12_heap_map(struct d3d12_heap *heap, uint64_t offset,
-        struct d3d12_resource *resource, void **data)
+static void d3d12_heap_update_mapping_locked(struct d3d12_heap *heap, uint64_t offset, uint64_t size)
+{
+    const struct vkd3d_vk_device_procs *vk_procs;
+    struct d3d12_device *device = heap->device;
+    VkMappedMemoryRange range;
+
+    if (!size)
+        return;
+
+    vk_procs = &device->vk_procs;
+
+    range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
+    range.pNext = NULL;
+    range.memory = heap->vk_memory;
+    range.offset = offset;
+    range.size = size;
+
+    VK_CALL(vkInvalidateMappedMemoryRanges(device->vk_device, 1, &range));
+}
+
+static HRESULT d3d12_heap_map(struct d3d12_heap *heap, uint64_t offset, uint64_t read_offset,
+        uint64_t read_size, struct d3d12_resource *resource, bool *was_unmapped, void **data)
 {
     struct d3d12_device *device = heap->device;
     HRESULT hr = S_OK;
@@ -448,6 +468,12 @@ static HRESULT d3d12_heap_map(struct d3d12_heap *heap, uint64_t offset,

assert(!resource->map_count || heap->map_ptr);

+    if (was_unmapped)
+        *was_unmapped = !heap->map_ptr;
+
+    if (heap->map_ptr)
+        d3d12_heap_update_mapping_locked(heap, offset + read_offset, read_size);
+
     if (!resource->map_count)
     {
         if (!heap->map_ptr)
@@ -1223,11 +1249,27 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_GetDevice(ID3D12Resource *iface,
     return d3d12_device_query_interface(resource->device, iid, device);
 }

+static uint64_t offset_and_size_from_d3d12_range(const D3D12_RANGE *range, uint64_t default_size, uint64_t *size)
+{
+    if (range)
+    {
+        *size = (range->End > range->Begin) ? range->End - range->Begin : 0;
+        return range->Begin;
+    }
+    else
+    {
+        *size = default_size;
+        return 0;
+    }
+}
+
 static HRESULT STDMETHODCALLTYPE d3d12_resource_Map(ID3D12Resource *iface, UINT sub_resource,
         const D3D12_RANGE *read_range, void **data)
 {
     struct d3d12_resource *resource = impl_from_ID3D12Resource(iface);
     unsigned int sub_resource_count;
+    uint64_t read_offset, read_size;
+    bool was_unmapped;
     HRESULT hr;

TRACE("iface %p, sub_resource %u, read_range %p, data %p.\n",
@@ -1259,11 +1301,15 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_Map(ID3D12Resource *iface, UINT
         return E_NOTIMPL;
     }

-    WARN("Ignoring read range %p.\n", read_range);
+    read_offset = offset_and_size_from_d3d12_range(read_range, resource->desc.Width, &read_size);

-    if (FAILED(hr = d3d12_heap_map(resource->heap, resource->heap_offset, resource, data)))
+    if (FAILED(hr = d3d12_heap_map(resource->heap, resource->heap_offset, read_offset, read_size, resource,
+            &was_unmapped, data)))
         WARN("Failed to map resource %p, hr %#x.\n", resource, hr);

+    if (was_unmapped && read_range)
+        WARN("Ignored read range %p.\n", read_range);
+
     if (data)
         TRACE("Returning pointer %p.\n", *data);

@@ -1381,7 +1427,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_WriteToSubresource(ID3D12Resourc
     TRACE("Offset %#"PRIx64", size %#"PRIx64", row pitch %#"PRIx64", depth pitch %#"PRIx64".\n",
             vk_layout.offset, vk_layout.size, vk_layout.rowPitch, vk_layout.depthPitch);

-    if (FAILED(hr = d3d12_heap_map(resource->heap, resource->heap_offset, resource, (void **)&dst_data)))
+    if (FAILED(hr = d3d12_heap_map(resource->heap, resource->heap_offset, 0, 0, resource, NULL, (void **)&dst_data)))
     {
         WARN("Failed to map resource %p, hr %#x.\n", resource, hr);
         return hr;
@@ -1469,7 +1515,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_ReadFromSubresource(ID3D12Resour
     TRACE("Offset %#"PRIx64", size %#"PRIx64", row pitch %#"PRIx64", depth pitch %#"PRIx64".\n",
             vk_layout.offset, vk_layout.size, vk_layout.rowPitch, vk_layout.depthPitch);

-    if (FAILED(hr = d3d12_heap_map(resource->heap, resource->heap_offset, resource, (void **)&src_data)))
+    if (FAILED(hr = d3d12_heap_map(resource->heap, resource->heap_offset, 0, 0, resource, NULL, (void **)&src_data)))
     {
         WARN("Failed to map resource %p, hr %#x.\n", resource, hr);
         return hr;