vkd3d: Create one vkd3d queue per Vulkan device queue.

Signed-off-by: Philip Rebohle <philip.rebohle@tu-dortmund.de>

libs/vkd3d/command.c

@@ -42,8 +42,8 @@ static HRESULT vkd3d_create_binary_semaphore(struct d3d12_device *device, VkSema
     return hresult_from_vk_result(vr);
 }
 
-HRESULT vkd3d_queue_create(struct d3d12_device *device,
+HRESULT vkd3d_queue_create(struct d3d12_device *device, uint32_t family_index, uint32_t queue_index,
-        uint32_t family_index, const VkQueueFamilyProperties *properties, struct vkd3d_queue **queue)
+        const VkQueueFamilyProperties *properties, struct vkd3d_queue **queue)
 {
     const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
     VkCommandBufferAllocateInfo allocate_info;
@@ -70,7 +70,7 @@ HRESULT vkd3d_queue_create(struct d3d12_device *device,
     object->timestamp_bits = properties->timestampValidBits;
     object->virtual_queue_count = 0;
 
-    VK_CALL(vkGetDeviceQueue(device->vk_device, family_index, 0, &object->vk_queue));
+    VK_CALL(vkGetDeviceQueue(device->vk_device, family_index, queue_index, &object->vk_queue));
 
     TRACE("Created queue %p for queue family index %u.\n", object, family_index);
 
@@ -10099,7 +10099,7 @@ static void d3d12_command_queue_bind_sparse(struct d3d12_command_queue *command_
     queue = command_queue->vkd3d_queue;
 
     if (!(queue->vk_queue_flags & VK_QUEUE_SPARSE_BINDING_BIT))
-        queue_sparse = command_queue->device->queues[VKD3D_QUEUE_FAMILY_SPARSE_BINDING];
+        queue_sparse = command_queue->device->queue_families[VKD3D_QUEUE_FAMILY_SPARSE_BINDING]->queues[0];
     else
         queue_sparse = queue;
 

libs/vkd3d/device.c

@@ -1772,62 +1772,29 @@ static void d3d12_device_destroy_vkd3d_queues(struct d3d12_device *device)
                 device->queue_families[j] = NULL;
         }
 
-        vkd3d_free(queue_family);
+        for (i = 0; i < queue_family->queue_count; i++)
-    }
-
-    for (i = 0; i < VKD3D_QUEUE_FAMILY_COUNT; i++)
-    {
-        struct vkd3d_queue *queue = device->queues[i];
-
-        if (!queue)
-            continue;
-
-        /* Don't destroy the same queue twice */
-        for (j = i; j < VKD3D_QUEUE_FAMILY_COUNT; j++)
         {
-            if (device->queues[j] == queue)
+            if (queue_family->queues[i])
-                device->queues[j] = NULL;
+                vkd3d_queue_destroy(queue_family->queues[i], device);
         }
 
-        vkd3d_queue_destroy(queue, device);
+        vkd3d_free(queue_family->queues);
+        vkd3d_free(queue_family);
     }
 }
 
 static HRESULT d3d12_device_create_vkd3d_queues(struct d3d12_device *device,
         const struct vkd3d_device_queue_info *queue_info)
 {
-    unsigned int i, j;
+    unsigned int i, j, k;
     HRESULT hr;
 
     device->unique_queue_mask = 0;
     device->queue_family_count = 0;
-    memset(device->queues, 0, sizeof(device->queues));
     memset(device->queue_families, 0, sizeof(device->queue_families));
     memset(device->queue_family_indices, 0, sizeof(device->queue_family_indices));
 
-    for (i = 0; i < VKD3D_QUEUE_FAMILY_COUNT; i++)
+    for (i = 0, k = 0; i < VKD3D_QUEUE_FAMILY_COUNT; i++)
-    {
-        if (queue_info->family_index[i] == VK_QUEUE_FAMILY_IGNORED)
-            continue;
-
-        for (j = 0; j < i; j++)
-        {
-            if (queue_info->family_index[i] == queue_info->family_index[j])
-                device->queues[i] = device->queues[j];
-        }
-
-        if (device->queues[i])
-            continue;
-
-        if (FAILED((hr = vkd3d_queue_create(device, queue_info->family_index[i],
-                &queue_info->vk_properties[i], &device->queues[i]))))
-            goto out_destroy_queues;
-
-        if (i != VKD3D_QUEUE_FAMILY_INTERNAL_COMPUTE)
-            device->unique_queue_mask |= 1u << i;
-    }
-
-    for (i = 0; i < VKD3D_QUEUE_FAMILY_COUNT; i++)
     {
         struct vkd3d_queue_family_info *info;
 
@@ -1840,19 +1807,39 @@ static HRESULT d3d12_device_create_vkd3d_queues(struct d3d12_device *device,
         if (device->queue_families[i])
             continue;
 
-        if (!(info = vkd3d_malloc(sizeof(*info))))
+        if (!(info = vkd3d_calloc(1, sizeof(*info))))
         {
             hr = E_OUTOFMEMORY;
             goto out_destroy_queues;
         }
 
-        info->queues = &device->queues[i];
+        if (queue_info->family_index[i] != VK_QUEUE_FAMILY_IGNORED)
-        info->queue_count = 1;
+        {
+            info->queue_count = queue_info->vk_queue_create_info[k++].queueCount;
+
+            if (!(info->queues = vkd3d_calloc(info->queue_count, sizeof(*info->queues))))
+            {
+                hr = E_OUTOFMEMORY;
+                goto out_destroy_queues;
+            }
+
+            for (j = 0; j < info->queue_count; j++)
+            {
+                if (FAILED((hr = vkd3d_queue_create(device, queue_info->family_index[i],
+                        j, &queue_info->vk_properties[i], &info->queues[j]))))
+                    goto out_destroy_queues;
+            }
+        }
+
         info->vk_family_index = queue_info->family_index[i];
         info->vk_queue_flags = queue_info->vk_properties[i].queueFlags;
+        info->timestamp_bits = queue_info->vk_properties[i].timestampValidBits;
 
         device->queue_families[i] = info;
         device->queue_family_indices[device->queue_family_count++] = info->vk_family_index;
+
+        if (info->queue_count && i != VKD3D_QUEUE_FAMILY_INTERNAL_COMPUTE)
+            device->unique_queue_mask |= 1u << i;
     }
 
     return S_OK;
@@ -4458,7 +4445,7 @@ static D3D12_TILED_RESOURCES_TIER d3d12_device_determine_tiled_resources_tier(st
     if (!features->sparseBinding || !features->sparseResidencyAliased ||
             !features->sparseResidencyBuffer || !features->sparseResidencyImage2D ||
             !sparse_properties->residencyStandard2DBlockShape ||
-            !device->queues[VKD3D_QUEUE_FAMILY_SPARSE_BINDING])
+            !device->queue_families[VKD3D_QUEUE_FAMILY_SPARSE_BINDING]->queue_count)
         return D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED;
 
     if (!features->shaderResourceResidency || !features->shaderResourceMinLod ||
@@ -4653,7 +4640,7 @@ static void d3d12_device_caps_init_feature_options3(struct d3d12_device *device)
 {
     D3D12_FEATURE_DATA_D3D12_OPTIONS3 *options3 = &device->d3d12_caps.options3;
 
-    options3->CopyQueueTimestampQueriesSupported = !!device->queues[VKD3D_QUEUE_FAMILY_TRANSFER]->timestamp_bits;
+    options3->CopyQueueTimestampQueriesSupported = !!device->queue_families[VKD3D_QUEUE_FAMILY_TRANSFER]->timestamp_bits;
     options3->CastingFullyTypedFormatSupported = TRUE;
     options3->WriteBufferImmediateSupportFlags = D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT |
             D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE | D3D12_COMMAND_LIST_SUPPORT_FLAG_COPY;

libs/vkd3d/memory.c

@@ -678,7 +678,7 @@ static HRESULT vkd3d_memory_allocator_init_clear_queue(struct vkd3d_memory_alloc
     command_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
     command_pool_info.pNext = NULL;
     command_pool_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
-    command_pool_info.queueFamilyIndex = device->queues[VKD3D_QUEUE_FAMILY_INTERNAL_COMPUTE]->vk_family_index;
+    command_pool_info.queueFamilyIndex = device->queue_families[VKD3D_QUEUE_FAMILY_INTERNAL_COMPUTE]->vk_family_index;
 
     if ((vr = VK_CALL(vkCreateCommandPool(device->vk_device, &command_pool_info,
             NULL, &clear_queue->vk_command_pool))) < 0)
@@ -743,6 +743,9 @@ HRESULT vkd3d_memory_allocator_init(struct vkd3d_memory_allocator *allocator, st
     }
 
     vkd3d_va_map_init(&allocator->va_map);
+
+    allocator->vkd3d_queue = d3d12_device_allocate_vkd3d_queue(device,
+            device->queue_families[VKD3D_QUEUE_FAMILY_INTERNAL_COMPUTE]);
     return S_OK;
 }
 
@@ -818,7 +821,7 @@ static HRESULT vkd3d_memory_allocator_flush_clears_locked(struct vkd3d_memory_al
     struct vkd3d_memory_clear_queue *clear_queue = &allocator->clear_queue;
     const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs;
     VkTimelineSemaphoreSubmitInfoKHR timeline_info;
-    struct vkd3d_queue *queue, *internal_queue;
+    struct vkd3d_queue_family_info *queue_family;
     VkCommandBufferBeginInfo begin_info;
     uint32_t queue_mask, queue_index;
     VkCommandBuffer vk_cmd_buffer;
@@ -833,7 +836,6 @@ static HRESULT vkd3d_memory_allocator_flush_clears_locked(struct vkd3d_memory_al
     /* Record commands late so that we can simply remove allocations from
      * the queue if they got freed before the clear commands got dispatched,
      * rather than rewriting the command buffer or dispatching the clear */
-    internal_queue = device->queues[VKD3D_QUEUE_FAMILY_INTERNAL_COMPUTE];
     vk_cmd_buffer = clear_queue->vk_command_buffers[clear_queue->command_buffer_index];
 
     vkd3d_memory_allocator_wait_clear_semaphore(allocator, device,
@@ -871,7 +873,7 @@ static HRESULT vkd3d_memory_allocator_flush_clears_locked(struct vkd3d_memory_al
     }
 
 
-    if (!(vk_queue = vkd3d_queue_acquire(internal_queue)))
+    if (!(vk_queue = vkd3d_queue_acquire(allocator->vkd3d_queue)))
         return E_FAIL;
 
     memset(&timeline_info, 0, sizeof(timeline_info));
@@ -888,7 +890,7 @@ static HRESULT vkd3d_memory_allocator_flush_clears_locked(struct vkd3d_memory_al
     submit_info.pSignalSemaphores = &clear_queue->vk_semaphore;
 
     vr = VK_CALL(vkQueueSubmit(vk_queue, 1, &submit_info, VK_NULL_HANDLE));
-    vkd3d_queue_release(internal_queue);
+    vkd3d_queue_release(allocator->vkd3d_queue);
 
     if (vr < 0)
     {
@@ -914,18 +916,21 @@ static HRESULT vkd3d_memory_allocator_flush_clears_locked(struct vkd3d_memory_al
     while (queue_mask)
     {
         queue_index = vkd3d_bitmask_iter32(&queue_mask);
-        queue = device->queues[queue_index];
+        queue_family = device->queue_families[queue_index];
 
-        if (!(vk_queue = vkd3d_queue_acquire(queue)))
+        for (i = 0; i < queue_family->queue_count; i++)
-            return E_FAIL;
-
-        vr = VK_CALL(vkQueueSubmit(vk_queue, 1, &submit_info, VK_NULL_HANDLE));
-        vkd3d_queue_release(queue);
-
-        if (vr < 0)
         {
-            ERR("Failed to submit semaphore wait, vr %d.\n", vr);
+            if (!(vk_queue = vkd3d_queue_acquire(queue_family->queues[i])))
-            return hresult_from_vk_result(vr);
+                return E_FAIL;
+
+            vr = VK_CALL(vkQueueSubmit(vk_queue, 1, &submit_info, VK_NULL_HANDLE));
+            vkd3d_queue_release(queue_family->queues[i]);
+
+            if (vr < 0)
+            {
+                ERR("Failed to submit semaphore wait, vr %d.\n", vr);
+                return hresult_from_vk_result(vr);
+            }
         }
     }
 

libs/vkd3d/resource.c

@@ -2056,7 +2056,7 @@ static HRESULT d3d12_resource_bind_sparse_metadata(struct d3d12_resource *resour
     bind_info.signalSemaphoreCount = 0;
     bind_info.pSignalSemaphores = NULL;
 
-    vkd3d_queue = device->queues[VKD3D_QUEUE_FAMILY_SPARSE_BINDING];
+    vkd3d_queue = device->queue_families[VKD3D_QUEUE_FAMILY_SPARSE_BINDING]->queues[0];
 
     if (!(vk_queue = vkd3d_queue_acquire(vkd3d_queue)))
     {

libs/vkd3d/vkd3d_private.h

@@ -704,6 +704,7 @@ struct vkd3d_memory_allocator
 
     struct vkd3d_va_map va_map;
 
+    struct vkd3d_queue *vkd3d_queue;
     struct vkd3d_memory_clear_queue clear_queue;
 };
 
@@ -1793,9 +1794,8 @@ struct vkd3d_queue
 };
 
 VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue);
-HRESULT vkd3d_queue_create(struct d3d12_device *device,
+HRESULT vkd3d_queue_create(struct d3d12_device *device, uint32_t family_index, uint32_t queue_index,
-        uint32_t family_index, const VkQueueFamilyProperties *properties,
+        const VkQueueFamilyProperties *properties, struct vkd3d_queue **queue);
-        struct vkd3d_queue **queue);
 void vkd3d_queue_destroy(struct vkd3d_queue *queue, struct d3d12_device *device);
 void vkd3d_queue_release(struct vkd3d_queue *queue);
 
@@ -2482,6 +2482,7 @@ struct vkd3d_queue_family_info
     struct vkd3d_queue **queues;
     uint32_t queue_count;
     uint32_t vk_family_index;
+    uint32_t timestamp_bits;
     VkQueueFlags vk_queue_flags;
 };
 
@@ -2509,10 +2510,9 @@ struct d3d12_device
     struct vkd3d_vulkan_info vk_info;
     struct vkd3d_physical_device_info device_info;
 
-    struct vkd3d_queue *queues[VKD3D_QUEUE_FAMILY_COUNT];
     struct vkd3d_queue_family_info *queue_families[VKD3D_QUEUE_FAMILY_COUNT];
     uint32_t queue_family_indices[VKD3D_QUEUE_FAMILY_COUNT];
-    unsigned int queue_family_count;
+    uint32_t queue_family_count;
     uint32_t unique_queue_mask;
 
     struct vkd3d_instance *vkd3d_instance;