mirrors
/
vkd3d-proton
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

vkd3d: Create one vkd3d queue per Vulkan device queue. 

Signed-off-by: Philip Rebohle <philip.rebohle@tu-dortmund.de>
This commit is contained in:
Philip Rebohle 2021-03-13 04:39:15 +01:00 committed by Hans-Kristian Arntzen
parent 3cd93781ff
commit 1e3c91579e
5 changed files with 62 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libs/vkd3d/command.c
View File

@ -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,
uint32_t family_index, const VkQueueFamilyProperties *properties, struct vkd3d_queue **queue)
HRESULT vkd3d_queue_create(struct d3d12_device *device, uint32_t family_index, uint32_t queue_index,
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;

77
libs/vkd3d/device.c
View File

@ -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 < 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++)
for (i = 0; i < queue_family->queue_count; i++)
{
if (device->queues[j] == queue)
device->queues[j] = NULL;
if (queue_family->queues[i])
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++)
{
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++)
for (i = 0, k = 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];
info->queue_count = 1;
if (queue_info->family_index[i] != VK_QUEUE_FAMILY_IGNORED)
{
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;

35
libs/vkd3d/memory.c
View File

@ -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)))
return E_FAIL;
vr = VK_CALL(vkQueueSubmit(vk_queue, 1, &submit_info, VK_NULL_HANDLE));
vkd3d_queue_release(queue);
if (vr < 0)
for (i = 0; i < queue_family->queue_count; i++)
{
ERR("Failed to submit semaphore wait, vr %d.\n", vr);
return hresult_from_vk_result(vr);
if (!(vk_queue = vkd3d_queue_acquire(queue_family->queues[i])))
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);
}
}
}

2
libs/vkd3d/resource.c
View File

@ -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)))
{

10
libs/vkd3d/vkd3d_private.h
View File

@ -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,
uint32_t family_index, const VkQueueFamilyProperties *properties,
struct vkd3d_queue **queue);
HRESULT vkd3d_queue_create(struct d3d12_device *device, uint32_t family_index, uint32_t queue_index,
const VkQueueFamilyProperties *properties, 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;