diff options
Diffstat (limited to 'layers/core_validation.cpp')
| -rw-r--r-- | layers/core_validation.cpp | 329 |
1 files changed, 114 insertions, 215 deletions
diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp index a8bef895..666f58da 100644 --- a/layers/core_validation.cpp +++ b/layers/core_validation.cpp @@ -273,11 +273,6 @@ template layer_data *get_my_data_ptr<layer_data>(void *data_key, std::unordered_ static GLOBAL_CB_NODE *getCBNode(layer_data *, const VkCommandBuffer); #if MTMERGESOURCE -static void delete_queue_info_list(layer_data *my_data) { - // Process queue list, cleaning up each entry before deleting - my_data->queueMap.clear(); -} - // Add a fence, creating one if necessary to our list of fences/fenceIds static bool add_fence_info(layer_data *my_data, VkFence fence, VkQueue queue, uint64_t *fenceId) { bool skipCall = false; @@ -303,9 +298,6 @@ static bool add_fence_info(layer_data *my_data, VkFence fence, VkQueue queue, ui return skipCall; } -// Remove a fenceInfo from our list of fences/fenceIds -static void delete_fence_info(layer_data *my_data, VkFence fence) { my_data->fenceMap.erase(fence); } - // Record information when a fence is known to be signalled static void update_fence_tracking(layer_data *my_data, VkFence fence) { auto fence_item = my_data->fenceMap.find(fence); @@ -4647,6 +4639,8 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, cons dev_data->imageLayoutMap.clear(); dev_data->bufferViewMap.clear(); dev_data->bufferMap.clear(); + // Queues persist until device is destroyed + dev_data->queueMap.clear(); loader_platform_thread_unlock_mutex(&globalLock); #if MTMERGESOURCE bool skipCall = false; @@ -4673,8 +4667,6 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, cons } } } - // Queues persist until device is destroyed - delete_queue_info_list(dev_data); layer_debug_report_destroy_device(device); loader_platform_thread_unlock_mutex(&globalLock); @@ -5095,64 +5087,17 @@ vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; loader_platform_thread_lock_mutex(&globalLock); -#if MTMERGESOURCE - // TODO : Need to track fence and clear mem references when fence clears - // MTMTODO : Merge this code with code below to avoid duplicating efforts - uint64_t fenceId = 0; - skipCall = add_fence_info(dev_data, fence, queue, &fenceId); - - print_mem_list(dev_data); - printCBList(dev_data); - for (uint32_t submit_idx = 0; submit_idx < submitCount; submit_idx++) { - const VkSubmitInfo *submit = &pSubmits[submit_idx]; - for (uint32_t i = 0; i < submit->commandBufferCount; i++) { - pCBNode = getCBNode(dev_data, submit->pCommandBuffers[i]); - if (pCBNode) { - pCBNode->fenceId = fenceId; - pCBNode->lastSubmittedFence = fence; - pCBNode->lastSubmittedQueue = queue; - for (auto &function : pCBNode->validate_functions) { - skipCall |= function(); - } - for (auto &function : pCBNode->eventUpdates) { - skipCall |= function(queue); - } - } - } - - for (uint32_t i = 0; i < submit->waitSemaphoreCount; i++) { - VkSemaphore sem = submit->pWaitSemaphores[i]; - - if (dev_data->semaphoreMap.find(sem) != dev_data->semaphoreMap.end()) { - if (dev_data->semaphoreMap[sem].state != MEMTRACK_SEMAPHORE_STATE_SIGNALLED) { - skipCall = - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - (uint64_t)sem, __LINE__, MEMTRACK_NONE, "SEMAPHORE", - "vkQueueSubmit: Semaphore must be in signaled state before passing to pWaitSemaphores"); - } - dev_data->semaphoreMap[sem].state = MEMTRACK_SEMAPHORE_STATE_WAIT; - } - } - for (uint32_t i = 0; i < submit->signalSemaphoreCount; i++) { - VkSemaphore sem = submit->pSignalSemaphores[i]; - - if (dev_data->semaphoreMap.find(sem) != dev_data->semaphoreMap.end()) { - if (dev_data->semaphoreMap[sem].state != MEMTRACK_SEMAPHORE_STATE_UNSET) { - skipCall = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, (uint64_t)sem, __LINE__, MEMTRACK_NONE, - "SEMAPHORE", "vkQueueSubmit: Semaphore must not be currently signaled or in a wait state"); - } - dev_data->semaphoreMap[sem].state = MEMTRACK_SEMAPHORE_STATE_SIGNALLED; - } - } - } -#endif // First verify that fence is not in use if ((fence != VK_NULL_HANDLE) && (submitCount != 0) && dev_data->fenceMap[fence].in_use.load()) { skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, (uint64_t)(fence), __LINE__, DRAWSTATE_INVALID_FENCE, "DS", "Fence %#" PRIx64 " is already in use by another submission.", (uint64_t)(fence)); } + uint64_t fenceId = 0; + skipCall = add_fence_info(dev_data, fence, queue, &fenceId); + // TODO : Review these old print functions and clean up as appropriate + print_mem_list(dev_data); + printCBList(dev_data); // Now verify each individual submit std::unordered_set<VkQueue> processed_other_queues; for (uint32_t submit_idx = 0; submit_idx < submitCount; submit_idx++) { @@ -5160,42 +5105,60 @@ vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, vector<VkSemaphore> semaphoreList; for (uint32_t i = 0; i < submit->waitSemaphoreCount; ++i) { const VkSemaphore &semaphore = submit->pWaitSemaphores[i]; - if (dev_data->semaphoreMap[semaphore].signaled) { - dev_data->semaphoreMap[semaphore].signaled = 0; - dev_data->semaphoreMap[semaphore].in_use.fetch_sub(1); - } else { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, - "DS", "Queue %#" PRIx64 " is waiting on semaphore %#" PRIx64 " that has no way to be signaled.", - reinterpret_cast<uint64_t &>(queue), reinterpret_cast<const uint64_t &>(semaphore)); - } - const VkQueue &other_queue = dev_data->semaphoreMap[semaphore].queue; - if (other_queue != VK_NULL_HANDLE && !processed_other_queues.count(other_queue)) { - updateTrackedCommandBuffers(dev_data, queue, other_queue, fence); - processed_other_queues.insert(other_queue); + if (dev_data->semaphoreMap.find(semaphore) != dev_data->semaphoreMap.end()) { + if (dev_data->semaphoreMap[semaphore].signaled) { + dev_data->semaphoreMap[semaphore].signaled = false; + dev_data->semaphoreMap[semaphore].in_use.fetch_sub(1); + } else { + skipCall |= + log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, + reinterpret_cast<const uint64_t &>(semaphore), __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", + "Queue %#" PRIx64 " is waiting on semaphore %#" PRIx64 " that has no way to be signaled.", + reinterpret_cast<uint64_t &>(queue), reinterpret_cast<const uint64_t &>(semaphore)); + } + const VkQueue &other_queue = dev_data->semaphoreMap[semaphore].queue; + if (other_queue != VK_NULL_HANDLE && !processed_other_queues.count(other_queue)) { + updateTrackedCommandBuffers(dev_data, queue, other_queue, fence); + processed_other_queues.insert(other_queue); + } } } for (uint32_t i = 0; i < submit->signalSemaphoreCount; ++i) { const VkSemaphore &semaphore = submit->pSignalSemaphores[i]; - semaphoreList.push_back(semaphore); - if (dev_data->semaphoreMap[semaphore].signaled) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, - "DS", "Queue %#" PRIx64 " is signaling semaphore %#" PRIx64 - " that has already been signaled but not waited on by queue %#" PRIx64 ".", - reinterpret_cast<uint64_t &>(queue), reinterpret_cast<const uint64_t &>(semaphore), - reinterpret_cast<uint64_t &>(dev_data->semaphoreMap[semaphore].queue)); - } else { - dev_data->semaphoreMap[semaphore].signaled = 1; - dev_data->semaphoreMap[semaphore].queue = queue; + if (dev_data->semaphoreMap.find(semaphore) != dev_data->semaphoreMap.end()) { + semaphoreList.push_back(semaphore); + if (dev_data->semaphoreMap[semaphore].signaled) { + skipCall |= + log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, + reinterpret_cast<const uint64_t &>(semaphore), __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", + "Queue %#" PRIx64 " is signaling semaphore %#" PRIx64 + " that has already been signaled but not waited on by queue %#" PRIx64 ".", + reinterpret_cast<uint64_t &>(queue), reinterpret_cast<const uint64_t &>(semaphore), + reinterpret_cast<uint64_t &>(dev_data->semaphoreMap[semaphore].queue)); + } else { + dev_data->semaphoreMap[semaphore].signaled = true; + dev_data->semaphoreMap[semaphore].queue = queue; + } } } for (uint32_t i = 0; i < submit->commandBufferCount; i++) { skipCall |= ValidateCmdBufImageLayouts(submit->pCommandBuffers[i]); pCBNode = getCBNode(dev_data, submit->pCommandBuffers[i]); - pCBNode->semaphores = semaphoreList; - pCBNode->submitCount++; // increment submit count - skipCall |= validatePrimaryCommandBufferState(dev_data, pCBNode); + if (pCBNode) { + pCBNode->semaphores = semaphoreList; + pCBNode->submitCount++; // increment submit count + pCBNode->fenceId = fenceId; + pCBNode->lastSubmittedFence = fence; + pCBNode->lastSubmittedQueue = queue; + skipCall |= validatePrimaryCommandBufferState(dev_data, pCBNode); + // Call submit-time functions to validate/update state + for (auto &function : pCBNode->validate_functions) { + skipCall |= function(); + } + for (auto &function : pCBNode->eventUpdates) { + skipCall |= function(queue); + } + } } } // Update cmdBuffer-related data structs and mark fence in-use @@ -5203,20 +5166,7 @@ vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, loader_platform_thread_unlock_mutex(&globalLock); if (!skipCall) result = dev_data->device_dispatch_table->QueueSubmit(queue, submitCount, pSubmits, fence); -#if MTMERGESOURCE - loader_platform_thread_lock_mutex(&globalLock); - for (uint32_t submit_idx = 0; submit_idx < submitCount; submit_idx++) { - const VkSubmitInfo *submit = &pSubmits[submit_idx]; - for (uint32_t i = 0; i < submit->waitSemaphoreCount; i++) { - VkSemaphore sem = submit->pWaitSemaphores[i]; - if (dev_data->semaphoreMap.find(sem) != dev_data->semaphoreMap.end()) { - dev_data->semaphoreMap[sem].state = MEMTRACK_SEMAPHORE_STATE_UNSET; - } - } - } - loader_platform_thread_unlock_mutex(&globalLock); -#endif return result; } @@ -5560,19 +5510,17 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFen layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); bool skipCall = false; loader_platform_thread_lock_mutex(&globalLock); - if (dev_data->fenceMap[fence].in_use.load()) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - (uint64_t)(fence), __LINE__, DRAWSTATE_INVALID_FENCE, "DS", - "Fence %#" PRIx64 " is in use by a command buffer.", (uint64_t)(fence)); - } -#if MTMERGESOURCE - delete_fence_info(dev_data, fence); - auto item = dev_data->fenceMap.find(fence); - if (item != dev_data->fenceMap.end()) { - dev_data->fenceMap.erase(item); + auto fence_pair = dev_data->fenceMap.find(fence); + if (fence_pair != dev_data->fenceMap.end()) { + if (fence_pair->second.in_use.load()) { + skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, + (uint64_t)(fence), __LINE__, DRAWSTATE_INVALID_FENCE, "DS", + "Fence %#" PRIx64 " is in use by a command buffer.", (uint64_t)(fence)); + } + dev_data->fenceMap.erase(fence_pair); } -#endif loader_platform_thread_unlock_mutex(&globalLock); + if (!skipCall) dev_data->device_dispatch_table->DestroyFence(device, fence, pAllocator); } @@ -6031,7 +5979,6 @@ static bool validateCommandBuffersNotInUse(const layer_data *dev_data, VkCommand VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - bool commandBufferComplete = false; bool skipCall = false; loader_platform_thread_lock_mutex(&globalLock); // Verify that command buffers in pool are complete (not in-flight) @@ -6062,7 +6009,6 @@ vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocat VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - bool commandBufferComplete = false; bool skipCall = false; VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; @@ -10151,106 +10097,69 @@ vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip_call = false; -#if MTMERGESOURCE - //MTMTODO : Merge this code with the checks below loader_platform_thread_lock_mutex(&globalLock); - - for (uint32_t i = 0; i < bindInfoCount; i++) { - const VkBindSparseInfo *bindInfo = &pBindInfo[i]; + for (uint32_t bindIdx = 0; bindIdx < bindInfoCount; ++bindIdx) { + const VkBindSparseInfo &bindInfo = pBindInfo[bindIdx]; // Track objects tied to memory - for (uint32_t j = 0; j < bindInfo->bufferBindCount; j++) { - for (uint32_t k = 0; k < bindInfo->pBufferBinds[j].bindCount; k++) { - if (set_sparse_mem_binding(dev_data, bindInfo->pBufferBinds[j].pBinds[k].memory, - (uint64_t)bindInfo->pBufferBinds[j].buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, + for (uint32_t j = 0; j < bindInfo.bufferBindCount; j++) { + for (uint32_t k = 0; k < bindInfo.pBufferBinds[j].bindCount; k++) { + if (set_sparse_mem_binding(dev_data, bindInfo.pBufferBinds[j].pBinds[k].memory, + (uint64_t)bindInfo.pBufferBinds[j].buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "vkQueueBindSparse")) skip_call = true; } } - for (uint32_t j = 0; j < bindInfo->imageOpaqueBindCount; j++) { - for (uint32_t k = 0; k < bindInfo->pImageOpaqueBinds[j].bindCount; k++) { - if (set_sparse_mem_binding(dev_data, bindInfo->pImageOpaqueBinds[j].pBinds[k].memory, - (uint64_t)bindInfo->pImageOpaqueBinds[j].image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + for (uint32_t j = 0; j < bindInfo.imageOpaqueBindCount; j++) { + for (uint32_t k = 0; k < bindInfo.pImageOpaqueBinds[j].bindCount; k++) { + if (set_sparse_mem_binding(dev_data, bindInfo.pImageOpaqueBinds[j].pBinds[k].memory, + (uint64_t)bindInfo.pImageOpaqueBinds[j].image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkQueueBindSparse")) skip_call = true; } } - for (uint32_t j = 0; j < bindInfo->imageBindCount; j++) { - for (uint32_t k = 0; k < bindInfo->pImageBinds[j].bindCount; k++) { - if (set_sparse_mem_binding(dev_data, bindInfo->pImageBinds[j].pBinds[k].memory, - (uint64_t)bindInfo->pImageBinds[j].image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + for (uint32_t j = 0; j < bindInfo.imageBindCount; j++) { + for (uint32_t k = 0; k < bindInfo.pImageBinds[j].bindCount; k++) { + if (set_sparse_mem_binding(dev_data, bindInfo.pImageBinds[j].pBinds[k].memory, + (uint64_t)bindInfo.pImageBinds[j].image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkQueueBindSparse")) skip_call = true; } } - // Validate semaphore state - for (uint32_t i = 0; i < bindInfo->waitSemaphoreCount; i++) { - VkSemaphore sem = bindInfo->pWaitSemaphores[i]; - - if (dev_data->semaphoreMap.find(sem) != dev_data->semaphoreMap.end()) { - if (dev_data->semaphoreMap[sem].state != MEMTRACK_SEMAPHORE_STATE_SIGNALLED) { - skip_call = + for (uint32_t i = 0; i < bindInfo.waitSemaphoreCount; ++i) { + const VkSemaphore &semaphore = bindInfo.pWaitSemaphores[i]; + if (dev_data->semaphoreMap.find(semaphore) != dev_data->semaphoreMap.end()) { + if (dev_data->semaphoreMap[semaphore].signaled) { + dev_data->semaphoreMap[semaphore].signaled = false; + } else { + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - (uint64_t)sem, __LINE__, MEMTRACK_NONE, "SEMAPHORE", - "vkQueueBindSparse: Semaphore must be in signaled state before passing to pWaitSemaphores"); + reinterpret_cast<const uint64_t &>(semaphore), __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", + "vkQueueBindSparse: Queue %#" PRIx64 " is waiting on semaphore %#" PRIx64 + " that has no way to be signaled.", + reinterpret_cast<const uint64_t &>(queue), reinterpret_cast<const uint64_t &>(semaphore)); } - dev_data->semaphoreMap[sem].state = MEMTRACK_SEMAPHORE_STATE_WAIT; } } - for (uint32_t i = 0; i < bindInfo->signalSemaphoreCount; i++) { - VkSemaphore sem = bindInfo->pSignalSemaphores[i]; - - if (dev_data->semaphoreMap.find(sem) != dev_data->semaphoreMap.end()) { - if (dev_data->semaphoreMap[sem].state != MEMTRACK_SEMAPHORE_STATE_UNSET) { + for (uint32_t i = 0; i < bindInfo.signalSemaphoreCount; ++i) { + const VkSemaphore &semaphore = bindInfo.pSignalSemaphores[i]; + if (dev_data->semaphoreMap.find(semaphore) != dev_data->semaphoreMap.end()) { + if (dev_data->semaphoreMap[semaphore].signaled) { skip_call = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - (uint64_t)sem, __LINE__, MEMTRACK_NONE, "SEMAPHORE", - "vkQueueBindSparse: Semaphore must not be currently signaled or in a wait state"); + reinterpret_cast<const uint64_t &>(semaphore), __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", + "vkQueueBindSparse: Queue %#" PRIx64 " is signaling semaphore %#" PRIx64 + ", but that semaphore is already signaled.", + reinterpret_cast<const uint64_t &>(queue), reinterpret_cast<const uint64_t &>(semaphore)); } - dev_data->semaphoreMap[sem].state = MEMTRACK_SEMAPHORE_STATE_SIGNALLED; + dev_data->semaphoreMap[semaphore].signaled = true; } } } - print_mem_list(dev_data); loader_platform_thread_unlock_mutex(&globalLock); -#endif - loader_platform_thread_lock_mutex(&globalLock); - for (uint32_t bindIdx = 0; bindIdx < bindInfoCount; ++bindIdx) { - const VkBindSparseInfo &bindInfo = pBindInfo[bindIdx]; - for (uint32_t i = 0; i < bindInfo.waitSemaphoreCount; ++i) { - if (dev_data->semaphoreMap[bindInfo.pWaitSemaphores[i]].signaled) { - dev_data->semaphoreMap[bindInfo.pWaitSemaphores[i]].signaled = 0; - } else { - skip_call |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, - __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", - "Queue %#" PRIx64 " is waiting on semaphore %#" PRIx64 " that has no way to be signaled.", - (uint64_t)(queue), (uint64_t)(bindInfo.pWaitSemaphores[i])); - } - } - for (uint32_t i = 0; i < bindInfo.signalSemaphoreCount; ++i) { - dev_data->semaphoreMap[bindInfo.pSignalSemaphores[i]].signaled = 1; - } - } - loader_platform_thread_unlock_mutex(&globalLock); if (!skip_call) return dev_data->device_dispatch_table->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); -#if MTMERGESOURCE - // Update semaphore state - loader_platform_thread_lock_mutex(&globalLock); - for (uint32_t bind_info_idx = 0; bind_info_idx < bindInfoCount; bind_info_idx++) { - const VkBindSparseInfo *bindInfo = &pBindInfo[bind_info_idx]; - for (uint32_t i = 0; i < bindInfo->waitSemaphoreCount; i++) { - VkSemaphore sem = bindInfo->pWaitSemaphores[i]; - - if (dev_data->semaphoreMap.find(sem) != dev_data->semaphoreMap.end()) { - dev_data->semaphoreMap[sem].state = MEMTRACK_SEMAPHORE_STATE_UNSET; - } - } - } - loader_platform_thread_unlock_mutex(&globalLock); -#endif return result; } @@ -10262,10 +10171,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaph if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); SEMAPHORE_NODE* sNode = &dev_data->semaphoreMap[*pSemaphore]; - sNode->signaled = 0; + sNode->signaled = false; sNode->queue = VK_NULL_HANDLE; sNode->in_use.store(0); - sNode->state = MEMTRACK_SEMAPHORE_STATE_UNSET; loader_platform_thread_unlock_mutex(&globalLock); } return result; @@ -10388,14 +10296,17 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, if (pPresentInfo) { loader_platform_thread_lock_mutex(&globalLock); for (uint32_t i = 0; i < pPresentInfo->waitSemaphoreCount; ++i) { - if (dev_data->semaphoreMap[pPresentInfo->pWaitSemaphores[i]].signaled) { - dev_data->semaphoreMap[pPresentInfo->pWaitSemaphores[i]].signaled = 0; - } else { - skip_call |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, - __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", - "Queue %#" PRIx64 " is waiting on semaphore %#" PRIx64 " that has no way to be signaled.", - (uint64_t)(queue), (uint64_t)(pPresentInfo->pWaitSemaphores[i])); + const VkSemaphore &semaphore = pPresentInfo->pWaitSemaphores[i]; + if (dev_data->semaphoreMap.find(semaphore) != dev_data->semaphoreMap.end()) { + if (dev_data->semaphoreMap[semaphore].signaled) { + dev_data->semaphoreMap[semaphore].signaled = false; + } else { + skip_call |= + log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", + "Queue %#" PRIx64 " is waiting on semaphore %#" PRIx64 " that has no way to be signaled.", + reinterpret_cast<uint64_t &>(queue), reinterpret_cast<const uint64_t &>(semaphore)); + } } } VkDeviceMemory mem; @@ -10429,16 +10340,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, if (!skip_call) result = dev_data->device_dispatch_table->QueuePresentKHR(queue, pPresentInfo); -#if MTMERGESOURCE - loader_platform_thread_lock_mutex(&globalLock); - for (uint32_t i = 0; i < pPresentInfo->waitSemaphoreCount; i++) { - VkSemaphore sem = pPresentInfo->pWaitSemaphores[i]; - if (dev_data->semaphoreMap.find(sem) != dev_data->semaphoreMap.end()) { - dev_data->semaphoreMap[sem].state = MEMTRACK_SEMAPHORE_STATE_UNSET; - } - } - loader_platform_thread_unlock_mutex(&globalLock); -#endif + return result; } @@ -10447,16 +10349,16 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchai layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skipCall = false; -#if MTMERGESOURCE + loader_platform_thread_lock_mutex(&globalLock); if (semaphore != VK_NULL_HANDLE && dev_data->semaphoreMap.find(semaphore) != dev_data->semaphoreMap.end()) { - if (dev_data->semaphoreMap[semaphore].state != MEMTRACK_SEMAPHORE_STATE_UNSET) { + if (dev_data->semaphoreMap[semaphore].signaled) { skipCall = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - (uint64_t)semaphore, __LINE__, MEMTRACK_NONE, "SEMAPHORE", + reinterpret_cast<const uint64_t &>(semaphore), __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", "vkAcquireNextImageKHR: Semaphore must not be currently signaled or in a wait state"); } - dev_data->semaphoreMap[semaphore].state = MEMTRACK_SEMAPHORE_STATE_SIGNALLED; + dev_data->semaphoreMap[semaphore].signaled = true; dev_data->semaphoreMap[semaphore].in_use.fetch_add(1); } auto fence_data = dev_data->fenceMap.find(fence); @@ -10464,15 +10366,12 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchai fence_data->second.swapchain = swapchain; } loader_platform_thread_unlock_mutex(&globalLock); -#endif + if (!skipCall) { result = dev_data->device_dispatch_table->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); } - loader_platform_thread_lock_mutex(&globalLock); - // FIXME/TODO: Need to add some thing code the "fence" parameter - dev_data->semaphoreMap[semaphore].signaled = 1; - loader_platform_thread_unlock_mutex(&globalLock); + return result; } |