Mesa (main): radv: implement vkQueueSubmit2KHR()
GitLab Mirror
gitlab-mirror at kemper.freedesktop.org
Fri Nov 26 14:24:57 UTC 2021
Module: Mesa
Branch: main
Commit: 3da7d10d9bb6b6e8c9d87633244dc54692ac2866
URL: http://cgit.freedesktop.org/mesa/mesa/commit/?id=3da7d10d9bb6b6e8c9d87633244dc54692ac2866
Author: Samuel Pitoiset <samuel.pitoiset at gmail.com>
Date: Thu Oct 14 09:55:16 2021 +0200
radv: implement vkQueueSubmit2KHR()
Signed-off-by: Samuel Pitoiset <samuel.pitoiset at gmail.com>
Reviewed-by: Bas Nieuwenhuizen <bas at basnieuwenhuizen.nl>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/13549>
---
src/amd/vulkan/radv_device.c | 173 +++++++++++++++++++++++--------------------
1 file changed, 93 insertions(+), 80 deletions(-)
diff --git a/src/amd/vulkan/radv_device.c b/src/amd/vulkan/radv_device.c
index 816a7f6a9ca..44feeea73a9 100644
--- a/src/amd/vulkan/radv_device.c
+++ b/src/amd/vulkan/radv_device.c
@@ -4416,7 +4416,7 @@ struct radv_deferred_queue_submission {
uint32_t image_bind_count;
bool flush_caches;
- VkPipelineStageFlags wait_dst_stage_mask;
+ VkPipelineStageFlags2KHR wait_dst_stage_mask;
struct radv_semaphore_part **wait_semaphores;
uint32_t wait_semaphore_count;
struct radv_semaphore_part **signal_semaphores;
@@ -4437,8 +4437,8 @@ struct radv_deferred_queue_submission {
};
struct radv_queue_submission {
- const VkCommandBuffer *cmd_buffers;
- uint32_t cmd_buffer_count;
+ const VkCommandBufferSubmitInfoKHR *cmd_buffer_infos;
+ uint32_t cmd_buffer_info_count;
/* Sparse bindings that happen on a queue. */
const VkSparseBufferMemoryBindInfo *buffer_binds;
@@ -4449,17 +4449,15 @@ struct radv_queue_submission {
uint32_t image_bind_count;
bool flush_caches;
- VkPipelineStageFlags wait_dst_stage_mask;
- const VkSemaphore *wait_semaphores;
- uint32_t wait_semaphore_count;
- const VkSemaphore *signal_semaphores;
- uint32_t signal_semaphore_count;
- VkFence fence;
+ VkPipelineStageFlags2KHR wait_dst_stage_mask;
- const uint64_t *wait_values;
- uint32_t wait_value_count;
- const uint64_t *signal_values;
- uint32_t signal_value_count;
+ const VkSemaphoreSubmitInfoKHR *wait_semaphore_infos;
+ uint32_t wait_semaphore_info_count;
+
+ const VkSemaphoreSubmitInfoKHR *signal_semaphore_infos;
+ uint32_t signal_semaphore_info_count;
+
+ VkFence fence;
};
static VkResult radv_queue_trigger_submission(struct radv_deferred_queue_submission *submission,
@@ -4475,13 +4473,13 @@ radv_create_deferred_submission(struct radv_queue *queue,
size_t size = sizeof(struct radv_deferred_queue_submission);
uint32_t temporary_count = 0;
- for (uint32_t i = 0; i < submission->wait_semaphore_count; ++i) {
- RADV_FROM_HANDLE(radv_semaphore, semaphore, submission->wait_semaphores[i]);
+ for (uint32_t i = 0; i < submission->wait_semaphore_info_count; ++i) {
+ RADV_FROM_HANDLE(radv_semaphore, semaphore, submission->wait_semaphore_infos[i].semaphore);
if (semaphore->temporary.kind != RADV_SEMAPHORE_NONE)
++temporary_count;
}
- size += submission->cmd_buffer_count * sizeof(VkCommandBuffer);
+ size += submission->cmd_buffer_info_count * sizeof(VkCommandBuffer);
size += submission->buffer_bind_count * sizeof(VkSparseBufferMemoryBindInfo);
size += submission->image_opaque_bind_count * sizeof(VkSparseImageOpaqueMemoryBindInfo);
size += submission->image_bind_count * sizeof(VkSparseImageMemoryBindInfo);
@@ -4489,12 +4487,12 @@ radv_create_deferred_submission(struct radv_queue *queue,
for (uint32_t i = 0; i < submission->image_bind_count; ++i)
size += submission->image_binds[i].bindCount * sizeof(VkSparseImageMemoryBind);
- size += submission->wait_semaphore_count * sizeof(struct radv_semaphore_part *);
+ size += submission->wait_semaphore_info_count * sizeof(struct radv_semaphore_part *);
+ size += submission->wait_semaphore_info_count * sizeof(uint64_t);
size += temporary_count * sizeof(struct radv_semaphore_part);
- size += submission->signal_semaphore_count * sizeof(struct radv_semaphore_part *);
- size += submission->wait_value_count * sizeof(uint64_t);
- size += submission->signal_value_count * sizeof(uint64_t);
- size += submission->wait_semaphore_count * sizeof(struct radv_timeline_waiter);
+ size += submission->signal_semaphore_info_count * sizeof(struct radv_semaphore_part *);
+ size += submission->signal_semaphore_info_count * sizeof(uint64_t);
+ size += submission->wait_semaphore_info_count * sizeof(struct radv_timeline_waiter); /* legacy */
deferred = calloc(1, size);
if (!deferred)
@@ -4503,13 +4501,12 @@ radv_create_deferred_submission(struct radv_queue *queue,
deferred->queue = queue;
deferred->cmd_buffers = (void *)(deferred + 1);
- deferred->cmd_buffer_count = submission->cmd_buffer_count;
- if (submission->cmd_buffer_count) {
- memcpy(deferred->cmd_buffers, submission->cmd_buffers,
- submission->cmd_buffer_count * sizeof(*deferred->cmd_buffers));
+ deferred->cmd_buffer_count = submission->cmd_buffer_info_count;
+ for (uint32_t i = 0; i < submission->cmd_buffer_info_count; i++) {
+ deferred->cmd_buffers[i] = submission->cmd_buffer_infos[i].commandBuffer;
}
- deferred->buffer_binds = (void *)(deferred->cmd_buffers + submission->cmd_buffer_count);
+ deferred->buffer_binds = (void *)(deferred->cmd_buffers + submission->cmd_buffer_info_count);
deferred->buffer_bind_count = submission->buffer_bind_count;
if (submission->buffer_bind_count) {
memcpy(deferred->buffer_binds, submission->buffer_binds,
@@ -4541,11 +4538,11 @@ radv_create_deferred_submission(struct radv_queue *queue,
deferred->wait_dst_stage_mask = submission->wait_dst_stage_mask;
deferred->wait_semaphores = (void *)sparse_image_binds;
- deferred->wait_semaphore_count = submission->wait_semaphore_count;
+ deferred->wait_semaphore_count = submission->wait_semaphore_info_count;
deferred->signal_semaphores =
(void *)(deferred->wait_semaphores + deferred->wait_semaphore_count);
- deferred->signal_semaphore_count = submission->signal_semaphore_count;
+ deferred->signal_semaphore_count = submission->signal_semaphore_info_count;
deferred->fence = submission->fence;
@@ -4553,42 +4550,37 @@ radv_create_deferred_submission(struct radv_queue *queue,
(void *)(deferred->signal_semaphores + deferred->signal_semaphore_count);
deferred->temporary_semaphore_part_count = temporary_count;
+ deferred->wait_values = (void *)(deferred->temporary_semaphore_parts + temporary_count);
+ deferred->signal_values = deferred->wait_values + submission->wait_semaphore_info_count;
+
uint32_t temporary_idx = 0;
- for (uint32_t i = 0; i < submission->wait_semaphore_count; ++i) {
- RADV_FROM_HANDLE(radv_semaphore, semaphore, submission->wait_semaphores[i]);
+ for (uint32_t i = 0; i < submission->wait_semaphore_info_count; ++i) {
+ RADV_FROM_HANDLE(radv_semaphore, semaphore, submission->wait_semaphore_infos[i].semaphore);
if (semaphore->temporary.kind != RADV_SEMAPHORE_NONE) {
deferred->wait_semaphores[i] = &deferred->temporary_semaphore_parts[temporary_idx];
deferred->temporary_semaphore_parts[temporary_idx] = semaphore->temporary;
semaphore->temporary.kind = RADV_SEMAPHORE_NONE;
++temporary_idx;
- } else
+ } else {
deferred->wait_semaphores[i] = &semaphore->permanent;
+ }
+ deferred->wait_values[i] = submission->wait_semaphore_infos[i].value;
}
- for (uint32_t i = 0; i < submission->signal_semaphore_count; ++i) {
- RADV_FROM_HANDLE(radv_semaphore, semaphore, submission->signal_semaphores[i]);
+ for (uint32_t i = 0; i < submission->signal_semaphore_info_count; ++i) {
+ RADV_FROM_HANDLE(radv_semaphore, semaphore, submission->signal_semaphore_infos[i].semaphore);
if (semaphore->temporary.kind != RADV_SEMAPHORE_NONE) {
deferred->signal_semaphores[i] = &semaphore->temporary;
} else {
deferred->signal_semaphores[i] = &semaphore->permanent;
}
+ deferred->signal_values[i] = submission->signal_semaphore_infos[i].value;
}
- deferred->wait_values = (void *)(deferred->temporary_semaphore_parts + temporary_count);
- if (submission->wait_value_count) {
- memcpy(deferred->wait_values, submission->wait_values,
- submission->wait_value_count * sizeof(uint64_t));
- }
- deferred->signal_values = deferred->wait_values + submission->wait_value_count;
- if (submission->signal_value_count) {
- memcpy(deferred->signal_values, submission->signal_values,
- submission->signal_value_count * sizeof(uint64_t));
- }
-
- deferred->wait_nodes = (void *)(deferred->signal_values + submission->signal_value_count);
+ deferred->wait_nodes = (void *)(deferred->signal_values + submission->signal_semaphore_info_count);
/* This is worst-case. radv_queue_enqueue_submission will fill in further, but this
* ensure the submission is not accidentally triggered early when adding wait timelines. */
- deferred->submission_wait_count = 1 + submission->wait_semaphore_count;
+ deferred->submission_wait_count = 1 + submission->wait_semaphore_info_count;
*out = deferred;
return VK_SUCCESS;
@@ -4972,13 +4964,15 @@ radv_signal_fence(struct radv_queue *queue, VkFence fence)
}
static bool
-radv_submit_has_effects(const VkSubmitInfo *info)
+radv_submit_has_effects(const VkSubmitInfo2KHR *info)
{
- return info->commandBufferCount || info->waitSemaphoreCount || info->signalSemaphoreCount;
+ return info->commandBufferInfoCount || info->waitSemaphoreInfoCount ||
+ info->signalSemaphoreInfoCount;
}
VKAPI_ATTR VkResult VKAPI_CALL
-radv_QueueSubmit(VkQueue _queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
+radv_QueueSubmit2KHR(VkQueue _queue, uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits,
+ VkFence fence)
{
RADV_FROM_HANDLE(radv_queue, queue, _queue);
VkResult result;
@@ -4999,33 +4993,29 @@ radv_QueueSubmit(VkQueue _queue, uint32_t submitCount, const VkSubmitInfo *pSubm
if (!radv_submit_has_effects(pSubmits + i) && fence_idx != i)
continue;
- VkPipelineStageFlags wait_dst_stage_mask = 0;
- for (unsigned j = 0; j < pSubmits[i].waitSemaphoreCount; ++j) {
- wait_dst_stage_mask |= pSubmits[i].pWaitDstStageMask[j];
+ VkPipelineStageFlags2KHR wait_dst_stage_mask = 0;
+
+ /* Wait semaphores. */
+ for (unsigned j = 0; j < pSubmits[i].waitSemaphoreInfoCount; ++j) {
+ wait_dst_stage_mask |= pSubmits[i].pWaitSemaphoreInfos[j].stageMask;
}
- const VkTimelineSemaphoreSubmitInfo *timeline_info =
- vk_find_struct_const(pSubmits[i].pNext, TIMELINE_SEMAPHORE_SUBMIT_INFO);
+ /* Signal semaphores. */
+ for (unsigned j = 0; j < pSubmits[i].signalSemaphoreInfoCount; ++j) {
+ wait_dst_stage_mask |= pSubmits[i].pSignalSemaphoreInfos[j].stageMask;
+ }
result = radv_queue_submit(
queue, &(struct radv_queue_submission){
- .cmd_buffers = pSubmits[i].pCommandBuffers,
- .cmd_buffer_count = pSubmits[i].commandBufferCount,
+ .cmd_buffer_infos = pSubmits[i].pCommandBufferInfos,
+ .cmd_buffer_info_count = pSubmits[i].commandBufferInfoCount,
.wait_dst_stage_mask = wait_dst_stage_mask,
.flush_caches = !flushed_caches,
- .wait_semaphores = pSubmits[i].pWaitSemaphores,
- .wait_semaphore_count = pSubmits[i].waitSemaphoreCount,
- .signal_semaphores = pSubmits[i].pSignalSemaphores,
- .signal_semaphore_count = pSubmits[i].signalSemaphoreCount,
+ .wait_semaphore_infos = pSubmits[i].pWaitSemaphoreInfos,
+ .wait_semaphore_info_count = pSubmits[i].waitSemaphoreInfoCount,
+ .signal_semaphore_infos = pSubmits[i].pSignalSemaphoreInfos,
+ .signal_semaphore_info_count = pSubmits[i].signalSemaphoreInfoCount,
.fence = i == fence_idx ? fence : VK_NULL_HANDLE,
- .wait_values = timeline_info ? timeline_info->pWaitSemaphoreValues : NULL,
- .wait_value_count = timeline_info && timeline_info->pWaitSemaphoreValues
- ? timeline_info->waitSemaphoreValueCount
- : 0,
- .signal_values = timeline_info ? timeline_info->pSignalSemaphoreValues : NULL,
- .signal_value_count = timeline_info && timeline_info->pSignalSemaphoreValues
- ? timeline_info->signalSemaphoreValueCount
- : 0,
});
if (result != VK_SUCCESS)
return result;
@@ -5698,6 +5688,34 @@ radv_QueueBindSparse(VkQueue _queue, uint32_t bindInfoCount, const VkBindSparseI
const VkTimelineSemaphoreSubmitInfo *timeline_info =
vk_find_struct_const(pBindInfo[i].pNext, TIMELINE_SEMAPHORE_SUBMIT_INFO);
+ const uint64_t *wait_values = timeline_info && timeline_info->waitSemaphoreValueCount ?
+ timeline_info->pWaitSemaphoreValues : NULL;
+ const uint64_t *signal_values = timeline_info && timeline_info->signalSemaphoreValueCount ?
+ timeline_info->pSignalSemaphoreValues : NULL;
+
+ VkSemaphoreSubmitInfoKHR *wait_semaphore_infos =
+ malloc(sizeof(*wait_semaphore_infos) * pBindInfo[i].waitSemaphoreCount);
+ VkSemaphoreSubmitInfoKHR *signal_semaphore_infos =
+ malloc(sizeof(*signal_semaphore_infos) * pBindInfo[i].signalSemaphoreCount);
+
+ if (!wait_semaphore_infos || !signal_semaphore_infos)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+ for (uint32_t j = 0; j < pBindInfo[i].waitSemaphoreCount; j++) {
+ wait_semaphore_infos[j] = (VkSemaphoreSubmitInfoKHR) {
+ .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR,
+ .semaphore = pBindInfo[i].pWaitSemaphores[j],
+ .value = wait_values ? wait_values[j] : 0,
+ };
+ }
+
+ for (uint32_t j = 0; j < pBindInfo[i].signalSemaphoreCount; j++) {
+ signal_semaphore_infos[j] = (VkSemaphoreSubmitInfoKHR) {
+ .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR,
+ .semaphore = pBindInfo[i].pSignalSemaphores[j],
+ .value = signal_values ? signal_values[j] : 0,
+ };
+ }
VkResult result = radv_queue_submit(
queue, &(struct radv_queue_submission){
@@ -5707,21 +5725,16 @@ radv_QueueBindSparse(VkQueue _queue, uint32_t bindInfoCount, const VkBindSparseI
.image_opaque_bind_count = pBindInfo[i].imageOpaqueBindCount,
.image_binds = pBindInfo[i].pImageBinds,
.image_bind_count = pBindInfo[i].imageBindCount,
- .wait_semaphores = pBindInfo[i].pWaitSemaphores,
- .wait_semaphore_count = pBindInfo[i].waitSemaphoreCount,
- .signal_semaphores = pBindInfo[i].pSignalSemaphores,
- .signal_semaphore_count = pBindInfo[i].signalSemaphoreCount,
+ .wait_semaphore_infos = wait_semaphore_infos,
+ .wait_semaphore_info_count = pBindInfo[i].waitSemaphoreCount,
+ .signal_semaphore_infos = signal_semaphore_infos,
+ .signal_semaphore_info_count = pBindInfo[i].signalSemaphoreCount,
.fence = i == fence_idx ? fence : VK_NULL_HANDLE,
- .wait_values = timeline_info ? timeline_info->pWaitSemaphoreValues : NULL,
- .wait_value_count = timeline_info && timeline_info->pWaitSemaphoreValues
- ? timeline_info->waitSemaphoreValueCount
- : 0,
- .signal_values = timeline_info ? timeline_info->pSignalSemaphoreValues : NULL,
- .signal_value_count = timeline_info && timeline_info->pSignalSemaphoreValues
- ? timeline_info->signalSemaphoreValueCount
- : 0,
});
+ free(wait_semaphore_infos);
+ free(signal_semaphore_infos);
+
if (result != VK_SUCCESS)
return result;
}
More information about the mesa-commit
mailing list