From 4d0fce1bdc0e74b80899763d6c7eab5b2dd57dea Mon Sep 17 00:00:00 2001 From: Chris Forbes Date: Mon, 26 Jun 2017 12:11:16 -0700 Subject: layers: Declare aliases for std::mutex and its RAII wrappers I want to be able to swap out std::mutex for something the VS concurrency profiler can see, so let's get all the mentions of it to one place. --- layers/core_validation.cpp | 292 +++++++++++++++++++++++---------------------- 1 file changed, 148 insertions(+), 144 deletions(-) diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp index 840daec0..046f9c9f 100644 --- a/layers/core_validation.cpp +++ b/layers/core_validation.cpp @@ -95,6 +95,10 @@ std::string to_string(T var) { // This intentionally includes a cpp file #include "vk_safe_struct.cpp" +using mutex_t = std::mutex; +using lock_guard_t = std::lock_guard; +using unique_lock_t = std::unique_lock; + namespace core_validation { using std::unordered_map; @@ -204,7 +208,7 @@ void ValidateLayerOrdering(const TCreateInfo &createInfo) { } // TODO : This can be much smarter, using separate locks for separate global data -static std::mutex global_lock; +static mutex_t global_lock; // Return IMAGE_VIEW_STATE ptr for specified imageView or else NULL IMAGE_VIEW_STATE *GetImageViewState(const layer_data *dev_data, VkImageView image_view) { @@ -1906,7 +1910,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocati instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map); instance_data->dispatch_table.DestroyInstance(instance, pAllocator); - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); // Clean up logging callback, if any while (instance_data->logging_callback.size() > 0) { VkDebugReportCallbackEXT callback = instance_data->logging_callback.back(); @@ -2029,7 +2033,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDevice bool skip = false; instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(gpu), instance_layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto pd_state = GetPhysicalDeviceState(instance_data, gpu); // TODO: object_tracker should perhaps do this instead @@ -2111,7 +2115,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCall dispatch_key key = get_dispatch_key(device); layer_data *dev_data = GetLayerDataPtr(key, layer_data_map); // Free all the memory - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); deletePipelines(dev_data); dev_data->renderPassMap.clear(); for (auto ii = dev_data->commandBufferMap.begin(); ii != dev_data->commandBufferMap.end(); ++ii) { @@ -2699,7 +2703,7 @@ static bool PreCallValidateQueueSubmit(layer_data *dev_data, VkQueue queue, uint VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateQueueSubmit(dev_data, queue, submitCount, pSubmits, fence); lock.unlock(); @@ -2735,7 +2739,7 @@ VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAll const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateAllocateMemory(dev_data); if (!skip) { lock.unlock(); @@ -2806,7 +2810,7 @@ VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory mem, const layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); DEVICE_MEM_INFO *mem_info = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateFreeMemory(dev_data, mem, &mem_info, &obj_struct); if (!skip) { lock.unlock(); @@ -2991,7 +2995,7 @@ VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(VkDevice device, uint32_t fenceCoun uint64_t timeout) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); // Verify fence status of submitted fences - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateWaitForFences(dev_data, fenceCount, pFences); lock.unlock(); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; @@ -3015,7 +3019,7 @@ static void PostCallRecordGetFenceStatus(layer_data *dev_data, VkFence fence) { VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateGetFenceStatus(dev_data, fence); lock.unlock(); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; @@ -3043,7 +3047,7 @@ static void PostCallRecordGetDeviceQueue(layer_data *dev_data, uint32_t q_family VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); dev_data->dispatch_table.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); PostCallRecordGetDeviceQueue(dev_data, queueFamilyIndex, *pQueue); } @@ -3061,7 +3065,7 @@ static void PostCallRecordQueueWaitIdle(layer_data *dev_data, QUEUE_STATE *queue VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(VkQueue queue) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); QUEUE_STATE *queue_state = nullptr; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateQueueWaitIdle(dev_data, queue, &queue_state); lock.unlock(); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; @@ -3091,7 +3095,7 @@ static void PostCallRecordDeviceWaitIdle(layer_data *dev_data) { VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(VkDevice device) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDeviceWaitIdle(dev_data); lock.unlock(); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; @@ -3126,7 +3130,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const Vk // Common data objects used pre & post call FENCE_NODE *fence_node = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroyFence(dev_data, fence, &fence_node, &obj_struct); if (!skip) { @@ -3155,7 +3159,7 @@ VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semapho layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); SEMAPHORE_NODE *sema_node; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroySemaphore(dev_data, semaphore, &sema_node, &obj_struct); if (!skip) { lock.unlock(); @@ -3185,7 +3189,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const Vk layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); EVENT_STATE *event_state = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroyEvent(dev_data, event, &event_state, &obj_struct); if (!skip) { lock.unlock(); @@ -3219,7 +3223,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPo layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); QUERY_POOL_NODE *qp_state = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroyQueryPool(dev_data, queryPool, &qp_state, &obj_struct); if (!skip) { lock.unlock(); @@ -3325,7 +3329,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(VkDevice device, VkQueryPool size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); unordered_map> queries_in_flight; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateGetQueryPoolResults(dev_data, queryPool, firstQuery, queryCount, flags, &queries_in_flight); lock.unlock(); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; @@ -3529,7 +3533,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); BUFFER_STATE *buffer_state = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroyBuffer(dev_data, buffer, &buffer_state, &obj_struct); if (!skip) { lock.unlock(); @@ -3546,7 +3550,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView buffe // Common data objects used pre & post call BUFFER_VIEW_STATE *buffer_view_state = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); // Validate state before calling down chain, update common data if we'll be calling down chain bool skip = PreCallValidateDestroyBufferView(dev_data, bufferView, &buffer_view_state, &obj_struct); if (!skip) { @@ -3563,7 +3567,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const Vk layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); IMAGE_STATE *image_state = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroyImage(dev_data, image, &image_state, &obj_struct); if (!skip) { lock.unlock(); @@ -3593,7 +3597,7 @@ static bool PreCallValidateBindBufferMemory(layer_data *dev_data, VkBuffer buffe VkDeviceSize memoryOffset) { bool skip = false; if (buffer_state) { - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); // Track objects tied to memory uint64_t buffer_handle = HandleToUint64(buffer); skip = ValidateSetMemBinding(dev_data, mem, buffer_handle, kVulkanObjectTypeBuffer, "vkBindBufferMemory()"); @@ -3684,7 +3688,7 @@ static bool PreCallValidateBindBufferMemory(layer_data *dev_data, VkBuffer buffe static void PostCallRecordBindBufferMemory(layer_data *dev_data, VkBuffer buffer, BUFFER_STATE *buffer_state, VkDeviceMemory mem, VkDeviceSize memoryOffset) { if (buffer_state) { - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); // Track bound memory range information auto mem_info = GetMemObjInfo(dev_data, mem); if (mem_info) { @@ -3741,7 +3745,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageVi // Common data objects used pre & post call IMAGE_VIEW_STATE *image_view_state = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroyImageView(dev_data, imageView, &image_view_state, &obj_struct); if (!skip) { lock.unlock(); @@ -3757,7 +3761,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule s const VkAllocationCallbacks *pAllocator) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); dev_data->shaderModuleMap.erase(shaderModule); lock.unlock(); @@ -3788,7 +3792,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); PIPELINE_STATE *pipeline_state = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroyPipeline(dev_data, pipeline, &pipeline_state, &obj_struct); if (!skip) { lock.unlock(); @@ -3803,7 +3807,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); dev_data->pipelineLayoutMap.erase(pipelineLayout); lock.unlock(); @@ -3833,7 +3837,7 @@ VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, co layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); SAMPLER_STATE *sampler_state = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroySampler(dev_data, sampler, &sampler_state, &obj_struct); if (!skip) { lock.unlock(); @@ -3853,7 +3857,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescrip const VkAllocationCallbacks *pAllocator) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); dev_data->dispatch_table.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); PostCallRecordDestroyDescriptorSetLayout(dev_data, descriptorSetLayout); } @@ -3886,7 +3890,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPo layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); DESCRIPTOR_POOL_STATE *desc_pool_state = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroyDescriptorPool(dev_data, descriptorPool, &desc_pool_state, &obj_struct); if (!skip) { lock.unlock(); @@ -3927,7 +3931,7 @@ VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool com const VkCommandBuffer *pCommandBuffers) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); for (uint32_t i = 0; i < commandBufferCount; i++) { auto cb_node = GetCBNode(dev_data, pCommandBuffers[i]); @@ -3966,7 +3970,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkComman VkResult result = dev_data->dispatch_table.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); dev_data->commandPoolMap[*pCommandPool].createFlags = pCreateInfo->flags; dev_data->commandPoolMap[*pCommandPool].queueFamilyIndex = pCreateInfo->queueFamilyIndex; } @@ -3992,7 +3996,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(VkDevice device, const VkQueryPoo result = dev_data->dispatch_table.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); } if (result == VK_SUCCESS) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); QUERY_POOL_NODE *qp_node = &dev_data->queryPoolMap[*pQueryPool]; qp_node->createInfo = *pCreateInfo; } @@ -4034,7 +4038,7 @@ static void PostCallRecordDestroyCommandPool(layer_data *dev_data, VkCommandPool VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); COMMAND_POOL_NODE *cp_state = nullptr; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroyCommandPool(dev_data, commandPool, &cp_state); if (!skip) { lock.unlock(); @@ -4050,7 +4054,7 @@ VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool c layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto pPool = GetCommandPoolNode(dev_data, commandPool); skip |= checkCommandBuffersInFlight(dev_data, pPool, "reset command pool with", VALIDATION_ERROR_32800050); lock.unlock(); @@ -4073,7 +4077,7 @@ VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool c VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); for (uint32_t i = 0; i < fenceCount; ++i) { auto pFence = GetFenceNode(dev_data, pFences[i]); if (pFence && pFence->state == FENCE_INFLIGHT) { @@ -4146,7 +4150,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer fra layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); FRAMEBUFFER_STATE *framebuffer_state = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroyFramebuffer(dev_data, framebuffer, &framebuffer_state, &obj_struct); if (!skip) { lock.unlock(); @@ -4180,7 +4184,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass rende layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); RENDER_PASS_STATE *rp_state = nullptr; VK_OBJECT obj_struct; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateDestroyRenderPass(dev_data, renderPass, &rp_state, &obj_struct); if (!skip) { lock.unlock(); @@ -4195,7 +4199,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass rende VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCreateBuffer(dev_data, pCreateInfo); lock.unlock(); @@ -4213,7 +4217,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreat VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCreateBufferView(dev_data, pCreateInfo); lock.unlock(); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; @@ -4301,7 +4305,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateI result = dev_data->dispatch_table.CreateImage(device, pCreateInfo, pAllocator, pImage); } if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); PostCallRecordCreateImage(dev_data, pCreateInfo, pImage); } return result; @@ -4310,7 +4314,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateI VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCreateImageView(dev_data, pCreateInfo); lock.unlock(); if (skip) return VK_ERROR_VALIDATION_FAILED_EXT; @@ -4329,7 +4333,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateI layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.CreateFence(device, pCreateInfo, pAllocator, pFence); if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); auto &fence_node = dev_data->fenceMap[*pFence]; fence_node.fence = *pFence; fence_node.createInfo = *pCreateInfo; @@ -4427,7 +4431,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipeli layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); uint32_t i = 0; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); for (i = 0; i < count; i++) { pipe_state[i] = new PIPELINE_STATE; @@ -4479,7 +4483,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelin layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); uint32_t i = 0; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); for (i = 0; i < count; i++) { // TODO: Verify compute stage bits @@ -4522,7 +4526,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(VkDevice device, const VkSamplerCre layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.CreateSampler(device, pCreateInfo, pAllocator, pSampler); if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); dev_data->samplerMap[*pSampler] = unique_ptr(new SAMPLER_STATE(pSampler, pCreateInfo)); } return result; @@ -4543,7 +4547,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayout *pSetLayout) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCreateDescriptorSetLayout(dev_data, pCreateInfo); if (!skip) { lock.unlock(); @@ -4695,7 +4699,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPip VkResult result = dev_data->dispatch_table.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); PIPELINE_LAYOUT_NODE &plNode = dev_data->pipelineLayoutMap[*pPipelineLayout]; plNode.layout = *pPipelineLayout; plNode.set_layouts.resize(pCreateInfo->setLayoutCount); @@ -4722,7 +4726,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDes "Out of memory while attempting to allocate DESCRIPTOR_POOL_STATE in vkCreateDescriptorPool()")) return VK_ERROR_VALIDATION_FAILED_EXT; } else { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); dev_data->descriptorPoolMap[*pDescriptorPool] = pNewNode; } } else { @@ -4737,7 +4741,7 @@ VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptor layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.ResetDescriptorPool(device, descriptorPool, flags); if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); clearDescriptorPool(dev_data, device, descriptorPool, flags); } return result; @@ -4766,7 +4770,7 @@ static void PostCallRecordAllocateDescriptorSets(layer_data *dev_data, const VkD VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); cvdescriptorset::AllocateDescriptorSetsData common_data(pAllocateInfo->descriptorSetCount); bool skip = PreCallValidateAllocateDescriptorSets(dev_data, pAllocateInfo, &common_data); lock.unlock(); @@ -4832,7 +4836,7 @@ VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorP const VkDescriptorSet *pDescriptorSets) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); // Make sure that no sets being destroyed are in-flight - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateFreeDescriptorSets(dev_data, descriptorPool, count, pDescriptorSets); lock.unlock(); @@ -4876,7 +4880,7 @@ VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descri const VkCopyDescriptorSet *pDescriptorCopies) { // Only map look-up at top level is for device-level layer_data layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateUpdateDescriptorSets(dev_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); lock.unlock(); @@ -4895,7 +4899,7 @@ VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkC layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer); if (VK_SUCCESS == result) { - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto pPool = GetCommandPoolNode(dev_data, pCreateInfo->commandPool); if (pPool) { @@ -4935,7 +4939,7 @@ static void AddFramebufferBinding(layer_data *dev_data, GLOBAL_CB_NODE *cb_state VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); // Validate command buffer level GLOBAL_CB_NODE *cb_node = GetCBNode(dev_data, commandBuffer); if (cb_node) { @@ -5057,7 +5061,7 @@ VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { if ((VK_COMMAND_BUFFER_LEVEL_PRIMARY == pCB->createInfo.level) || @@ -5090,7 +5094,7 @@ VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) { VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); VkCommandPool cmdPool = pCB->createInfo.commandPool; auto pPool = GetCommandPoolNode(dev_data, cmdPool); @@ -5117,7 +5121,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipe VkPipeline pipeline) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); if (cb_state) { skip |= ValidateCmdQueueFlags(dev_data, cb_state, "vkCmdBindPipeline()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, @@ -5162,7 +5166,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_ const VkViewport *pViewports) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetViewport()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1e002415); @@ -5177,7 +5181,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t const VkRect2D *pScissors) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetScissor()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1d802415); @@ -5191,7 +5195,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetLineWidth()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1d602415); @@ -5218,7 +5222,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float float depthBiasSlopeFactor) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetDepthBias()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1cc02415); @@ -5242,7 +5246,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetBlendConstants()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1ca02415); @@ -5256,7 +5260,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, c VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetDepthBounds()", VK_QUEUE_GRAPHICS_BIT, VALIDATION_ERROR_1ce02415); @@ -5271,7 +5275,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffe uint32_t compareMask) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= @@ -5286,7 +5290,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffe VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= @@ -5301,7 +5305,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= @@ -5319,7 +5323,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(VkCommandBuffer commandBuffer, const uint32_t *pDynamicOffsets) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); if (cb_state) { skip |= ValidateCmdQueueFlags(dev_data, cb_state, "vkCmdBindDescriptorSets()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, @@ -5486,7 +5490,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkB bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); // TODO : Somewhere need to verify that IBs have correct usage state flagged - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto buffer_state = GetBufferState(dev_data, buffer); auto cb_node = GetCBNode(dev_data, commandBuffer); @@ -5542,7 +5546,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, u bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); // TODO : Somewhere need to verify that VBs have correct usage state flagged - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto cb_node = GetCBNode(dev_data, commandBuffer); if (cb_node) { @@ -5641,7 +5645,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDraw(VkCommandBuffer commandBuffer, uint32_t verte uint32_t firstVertex, uint32_t firstInstance) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *cb_state = nullptr; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCmdDraw(dev_data, commandBuffer, false, VK_PIPELINE_BIND_POINT_GRAPHICS, &cb_state, "vkCmdDraw()"); lock.unlock(); if (!skip) { @@ -5666,7 +5670,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_ uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *cb_state = nullptr; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCmdDrawIndexed(dev_data, commandBuffer, true, VK_PIPELINE_BIND_POINT_GRAPHICS, &cb_state, "vkCmdDrawIndexed()"); lock.unlock(); @@ -5702,7 +5706,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuff layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *cb_state = nullptr; BUFFER_STATE *buffer_state = nullptr; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCmdDrawIndirect(dev_data, commandBuffer, buffer, false, VK_PIPELINE_BIND_POINT_GRAPHICS, &cb_state, &buffer_state, "vkCmdDrawIndirect()"); lock.unlock(); @@ -5739,7 +5743,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *cb_state = nullptr; BUFFER_STATE *buffer_state = nullptr; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCmdDrawIndexedIndirect(dev_data, commandBuffer, buffer, true, VK_PIPELINE_BIND_POINT_GRAPHICS, &cb_state, &buffer_state, "vkCmdDrawIndexedIndirect()"); lock.unlock(); @@ -5764,7 +5768,7 @@ static void PostCallRecordCmdDispatch(layer_data *dev_data, GLOBAL_CB_NODE *cb_s VKAPI_ATTR void VKAPI_CALL CmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *cb_state = nullptr; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCmdDispatch(dev_data, commandBuffer, false, VK_PIPELINE_BIND_POINT_COMPUTE, &cb_state, "vkCmdDispatch()"); lock.unlock(); @@ -5797,7 +5801,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, Vk layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); GLOBAL_CB_NODE *cb_state = nullptr; BUFFER_STATE *buffer_state = nullptr; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCmdDispatchIndirect(dev_data, commandBuffer, buffer, false, VK_PIPELINE_BIND_POINT_COMPUTE, &cb_state, &buffer_state, "vkCmdDispatchIndirect()"); lock.unlock(); @@ -5812,7 +5816,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, Vk VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions) { layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto cb_node = GetCBNode(device_data, commandBuffer); auto src_buffer_state = GetBufferState(device_data, srcBuffer); @@ -5836,7 +5840,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage s const VkImageCopy *pRegions) { bool skip = false; layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto cb_node = GetCBNode(device_data, commandBuffer); auto src_image_state = GetImageState(device_data, srcImage); @@ -5875,7 +5879,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage s VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto cb_node = GetCBNode(dev_data, commandBuffer); auto src_image_state = GetImageState(dev_data, srcImage); @@ -5895,7 +5899,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, V VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions) { layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = false; auto cb_node = GetCBNode(device_data, commandBuffer); auto src_buffer_state = GetBufferState(device_data, srcBuffer); @@ -5920,7 +5924,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, V VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) { bool skip = false; layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto cb_node = GetCBNode(device_data, commandBuffer); auto src_image_state = GetImageState(device_data, srcImage); @@ -5945,7 +5949,7 @@ VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuff VkDeviceSize dataSize, const uint32_t *pData) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto cb_node = GetCBNode(dev_data, commandBuffer); auto dst_buff_state = GetBufferState(dev_data, dstBuffer); @@ -5977,7 +5981,7 @@ VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuff VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto cb_node = GetCBNode(device_data, commandBuffer); auto buffer_state = GetBufferState(device_data, dstBuffer); @@ -6000,7 +6004,7 @@ VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, ui bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); skip = PreCallValidateCmdClearAttachments(dev_data, commandBuffer, attachmentCount, pAttachments, rectCount, pRects); } if (!skip) dev_data->dispatch_table.CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); @@ -6010,7 +6014,7 @@ VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkI const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCmdClearColorImage(dev_data, commandBuffer, image, imageLayout, rangeCount, pRanges); if (!skip) { @@ -6024,7 +6028,7 @@ VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuff const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCmdClearDepthStencilImage(dev_data, commandBuffer, image, imageLayout, rangeCount, pRanges); if (!skip) { @@ -6038,7 +6042,7 @@ VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImag VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto cb_node = GetCBNode(dev_data, commandBuffer); auto src_image_state = GetImageState(dev_data, srcImage); @@ -6080,7 +6084,7 @@ bool setEventStageMask(VkQueue queue, VkCommandBuffer commandBuffer, VkEvent eve VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdSetEvent()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, @@ -6107,7 +6111,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent ev VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdResetEvent()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, @@ -6400,7 +6404,7 @@ VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); if (cb_state) { skip |= ValidateStageMasksAgainstQueueCapabilities(dev_data, cb_state, sourceStageMask, dstStageMask, "vkCmdWaitEvents", @@ -6475,7 +6479,7 @@ VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkP uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) { bool skip = false; layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *cb_state = GetCBNode(device_data, commandBuffer); if (cb_state) { skip |= PreCallValidateCmdPipelineBarrier(device_data, cb_state, commandBuffer, srcStageMask, dstStageMask, @@ -6511,7 +6515,7 @@ static bool setQueryState(VkQueue queue, VkCommandBuffer commandBuffer, QueryObj VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= ValidateCmdQueueFlags(dev_data, pCB, "vkCmdBeginQuery()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, @@ -6537,7 +6541,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryP VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); QueryObject query = {queryPool, slot}; GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); if (cb_state) { @@ -6570,7 +6574,7 @@ VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQu uint32_t queryCount) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); skip |= insideRenderPass(dev_data, cb_state, "vkCmdResetQueryPool()", VALIDATION_ERROR_1c600017); skip |= ValidateCmd(dev_data, cb_state, CMD_RESETQUERYPOOL, "VkCmdResetQueryPool()"); @@ -6627,7 +6631,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer VkDeviceSize stride, VkQueryResultFlags flags) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto cb_node = GetCBNode(dev_data, commandBuffer); auto dst_buff_state = GetBufferState(dev_data, dstBuffer); @@ -6668,7 +6672,7 @@ VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPip uint32_t offset, uint32_t size, const void *pValues) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); if (cb_state) { skip |= ValidateCmdQueueFlags(dev_data, cb_state, "vkCmdPushConstants()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, @@ -6713,7 +6717,7 @@ VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPi VkQueryPool queryPool, uint32_t slot) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *cb_state = GetCBNode(dev_data, commandBuffer); if (cb_state) { skip |= ValidateCmdQueueFlags(dev_data, cb_state, "vkCmdWriteTimestamp()", VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, @@ -6957,7 +6961,7 @@ static void PostCallRecordCreateFramebuffer(layer_data *dev_data, const VkFrameb VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateCreateFramebuffer(dev_data, pCreateInfo); lock.unlock(); @@ -7238,7 +7242,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShade VkResult res = dev_data->dispatch_table.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); if (res == VK_SUCCESS) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); unique_ptr new_shader_module(spirv_valid ? new shader_module(pCreateInfo) : new shader_module()); dev_data->shaderModuleMap[*pShaderModule] = std::move(new_shader_module); } @@ -7399,7 +7403,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(VkDevice device, const VkRenderP bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); // TODO: As part of wrapping up the mem_tracker/core_validation merge the following routine should be consolidated with // ValidateLayouts. skip |= ValidateRenderpassAttachmentUsage(dev_data, pCreateInfo); @@ -7505,7 +7509,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, con VkSubpassContents contents) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *cb_node = GetCBNode(dev_data, commandBuffer); auto render_pass_state = pRenderPassBegin ? GetRenderPassState(dev_data, pRenderPassBegin->renderPass) : nullptr; auto framebuffer = pRenderPassBegin ? GetFramebufferState(dev_data, pRenderPassBegin->framebuffer) : nullptr; @@ -7590,7 +7594,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, con VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { skip |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdNextSubpass()", VALIDATION_ERROR_1b600019); @@ -7624,7 +7628,7 @@ VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpa VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto pCB = GetCBNode(dev_data, commandBuffer); FRAMEBUFFER_STATE *framebuffer = NULL; if (pCB) { @@ -7896,7 +7900,7 @@ VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uin const VkCommandBuffer *pCommandBuffers) { bool skip = false; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); GLOBAL_CB_NODE *pCB = GetCBNode(dev_data, commandBuffer); if (pCB) { GLOBAL_CB_NODE *pSubCB = NULL; @@ -8010,7 +8014,7 @@ VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory mem, Vk bool skip = false; VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); DEVICE_MEM_INFO *mem_info = GetMemObjInfo(dev_data, mem); if (mem_info) { // TODO : This could me more fine-grained to track just region that is valid @@ -8047,7 +8051,7 @@ VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory mem) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); skip |= deleteMemRanges(dev_data, mem); lock.unlock(); if (!skip) { @@ -8167,7 +8171,7 @@ static bool ValidateMappedMemoryRangeDeviceLimits(layer_data *dev_data, const ch static bool PreCallValidateFlushMappedMemoryRanges(layer_data *dev_data, uint32_t mem_range_count, const VkMappedMemoryRange *mem_ranges) { bool skip = false; - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); skip |= ValidateAndCopyNoncoherentMemoryToDriver(dev_data, mem_range_count, mem_ranges); skip |= validateMemoryIsMapped(dev_data, "vkFlushMappedMemoryRanges", mem_range_count, mem_ranges); return skip; @@ -8187,14 +8191,14 @@ VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(VkDevice device, uint32_t static bool PreCallValidateInvalidateMappedMemoryRanges(layer_data *dev_data, uint32_t mem_range_count, const VkMappedMemoryRange *mem_ranges) { bool skip = false; - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); skip |= validateMemoryIsMapped(dev_data, "vkInvalidateMappedMemoryRanges", mem_range_count, mem_ranges); return skip; } static void PostCallRecordInvalidateMappedMemoryRanges(layer_data *dev_data, uint32_t mem_range_count, const VkMappedMemoryRange *mem_ranges) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); // Update our shadow copy with modified driver data CopyNoncoherentMemoryFromDriver(dev_data, mem_range_count, mem_ranges); } @@ -8217,7 +8221,7 @@ static bool PreCallValidateBindImageMemory(layer_data *dev_data, VkImage image, VkDeviceSize memoryOffset) { bool skip = false; if (image_state) { - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); // Track objects tied to memory uint64_t image_handle = HandleToUint64(image); skip = ValidateSetMemBinding(dev_data, mem, image_handle, kVulkanObjectTypeImage, "vkBindImageMemory()"); @@ -8274,7 +8278,7 @@ static bool PreCallValidateBindImageMemory(layer_data *dev_data, VkImage image, static void PostCallRecordBindImageMemory(layer_data *dev_data, VkImage image, IMAGE_STATE *image_state, VkDeviceMemory mem, VkDeviceSize memoryOffset) { if (image_state) { - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); // Track bound memory range information auto mem_info = GetMemObjInfo(dev_data, mem); if (mem_info) { @@ -8310,7 +8314,7 @@ VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event) { bool skip = false; VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto event_state = GetEventNode(dev_data, event); if (event_state) { event_state->needsSignaled = false; @@ -8341,7 +8345,7 @@ VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoC layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; bool skip = false; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto pFence = GetFenceNode(dev_data, fence); auto pQueue = GetQueueState(dev_data, queue); @@ -8446,7 +8450,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(VkDevice device, const VkSemaphor layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); if (result == VK_SUCCESS) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); SEMAPHORE_NODE *sNode = &dev_data->semaphoreMap[*pSemaphore]; sNode->signaler.first = VK_NULL_HANDLE; sNode->signaler.second = 0; @@ -8460,7 +8464,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(VkDevice device, const VkEventCreateI layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = dev_data->dispatch_table.CreateEvent(device, pCreateInfo, pAllocator, pEvent); if (result == VK_SUCCESS) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); dev_data->eventMap[*pEvent].needsSignaled = false; dev_data->eventMap[*pEvent].write_in_use = 0; dev_data->eventMap[*pEvent].stageMask = VkPipelineStageFlags(0); @@ -8720,7 +8724,7 @@ static void PostCallRecordCreateSwapchainKHR(layer_data *dev_data, VkResult resu VkSwapchainKHR *pSwapchain, SURFACE_STATE *surface_state, SWAPCHAIN_NODE *old_swapchain_state) { if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); auto swapchain_state = unique_ptr(new SWAPCHAIN_NODE(pCreateInfo, *pSwapchain)); if (VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR == pCreateInfo->presentMode || VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR == pCreateInfo->presentMode) { @@ -8760,7 +8764,7 @@ VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR s layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto swapchain_data = GetSwapchainNode(dev_data, swapchain); if (swapchain_data) { if (swapchain_data->images.size() > 0) { @@ -8796,7 +8800,7 @@ static bool PreCallValidateGetSwapchainImagesKHR(layer_data *device_data, SWAPCH uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) { bool skip = false; if (swapchain_state && pSwapchainImages) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); // Compare the preliminary value of *pSwapchainImageCount with the value this time: if (swapchain_state->vkGetSwapchainImagesKHRState == UNCALLED) { skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, @@ -8817,7 +8821,7 @@ static bool PreCallValidateGetSwapchainImagesKHR(layer_data *device_data, SWAPCH static void PostCallRecordGetSwapchainImagesKHR(layer_data *device_data, SWAPCHAIN_NODE *swapchain_state, VkDevice device, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); if (*pSwapchainImageCount > swapchain_state->images.size()) swapchain_state->images.resize(*pSwapchainImageCount); @@ -8886,7 +8890,7 @@ VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInf layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); bool skip = false; - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); auto queue_state = GetQueueState(dev_data, queue); for (uint32_t i = 0; i < pPresentInfo->waitSemaphoreCount; ++i) { @@ -9077,7 +9081,7 @@ static bool PreCallValidateCreateSharedSwapchainsKHR(layer_data *dev_data, uint3 std::vector &surface_state, std::vector &old_swapchain_state) { if (pCreateInfos) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); for (uint32_t i = 0; i < swapchainCount; i++) { surface_state.push_back(GetSurfaceState(dev_data->instance_data, pCreateInfos[i].surface)); old_swapchain_state.push_back(GetSwapchainNode(dev_data, pCreateInfos[i].oldSwapchain)); @@ -9147,7 +9151,7 @@ VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainK layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); bool skip = false; - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); if (fence == VK_NULL_HANDLE && semaphore == VK_NULL_HANDLE) { skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, @@ -9368,7 +9372,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevi instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); auto physical_device_state = GetPhysicalDeviceState(instance_data, physicalDevice); assert(physical_device_state); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateGetPhysicalDeviceQueueFamilyProperties(instance_data, physical_device_state, pQueueFamilyPropertyCount, pQueueFamilyProperties); @@ -9390,7 +9394,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysical instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); auto physical_device_state = GetPhysicalDeviceState(instance_data, physicalDevice); assert(physical_device_state); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); bool skip = PreCallValidateGetPhysicalDeviceQueueFamilyProperties2KHR(instance_data, physical_device_state, pQueueFamilyPropertyCount, pQueueFamilyProperties); @@ -9416,7 +9420,7 @@ static VkResult CreateSurface(VkInstance instance, TCreateInfo const *pCreateInf VkResult result = (instance_data->dispatch_table.*fptr)(instance, pCreateInfo, pAllocator, pSurface); if (result == VK_SUCCESS) { - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); instance_data->surface_map[*pSurface] = SURFACE_STATE(*pSurface); lock.unlock(); } @@ -9427,7 +9431,7 @@ static VkResult CreateSurface(VkInstance instance, TCreateInfo const *pCreateInf VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) { bool skip = false; instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto surface_state = GetSurfaceState(instance_data, surface); if ((surface_state) && (surface_state->swapchain)) { @@ -9466,7 +9470,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceMirPresentationSupportKHR(VkPhys bool skip = false; instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); const auto pd_state = GetPhysicalDeviceState(instance_data, physicalDevice); skip |= ValidatePhysicalDeviceQueueFamily(instance_data, pd_state, queueFamilyIndex, VALIDATION_ERROR_2d2009e2, @@ -9496,7 +9500,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(Vk bool skip = false; instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); const auto pd_state = GetPhysicalDeviceState(instance_data, physicalDevice); skip |= ValidatePhysicalDeviceQueueFamily(instance_data, pd_state, queueFamilyIndex, VALIDATION_ERROR_2f000a34, @@ -9525,7 +9529,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(VkPh bool skip = false; instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); const auto pd_state = GetPhysicalDeviceState(instance_data, physicalDevice); skip |= ValidatePhysicalDeviceQueueFamily(instance_data, pd_state, queueFamilyIndex, VALIDATION_ERROR_2f200a3a, @@ -9554,7 +9558,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(VkPhys bool skip = false; instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); const auto pd_state = GetPhysicalDeviceState(instance_data, physicalDevice); skip |= ValidatePhysicalDeviceQueueFamily(instance_data, pd_state, queueFamilyIndex, VALIDATION_ERROR_2f400a40, @@ -9584,7 +9588,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(VkPhy bool skip = false; instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); const auto pd_state = GetPhysicalDeviceState(instance_data, physicalDevice); skip |= ValidatePhysicalDeviceQueueFamily(instance_data, pd_state, queueFamilyIndex, VALIDATION_ERROR_2f600a46, @@ -9606,7 +9610,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysica VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) { auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto physical_device_state = GetPhysicalDeviceState(instance_data, physicalDevice); lock.unlock(); @@ -9624,7 +9628,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysica static void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(instance_layer_data *instanceData, VkPhysicalDevice physicalDevice, VkSurfaceCapabilities2KHR *pSurfaceCapabilities) { - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto physicalDeviceState = GetPhysicalDeviceState(instanceData, physicalDevice); physicalDeviceState->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState = QUERY_DETAILS; physicalDeviceState->surfaceCapabilities = pSurfaceCapabilities->surfaceCapabilities; @@ -9648,7 +9652,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysic static void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(instance_layer_data *instanceData, VkPhysicalDevice physicalDevice, VkSurfaceCapabilities2EXT *pSurfaceCapabilities) { - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto physicalDeviceState = GetPhysicalDeviceState(instanceData, physicalDevice); physicalDeviceState->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState = QUERY_DETAILS; physicalDeviceState->surfaceCapabilities.minImageCount = pSurfaceCapabilities->minImageCount; @@ -9682,7 +9686,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevi bool skip = false; auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); const auto pd_state = GetPhysicalDeviceState(instance_data, physicalDevice); auto surface_state = GetSurfaceState(instance_data, surface); @@ -9708,7 +9712,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(VkPhysica VkPresentModeKHR *pPresentModes) { bool skip = false; auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); // TODO: this isn't quite right. available modes may differ by surface AND physical device. auto physical_device_state = GetPhysicalDeviceState(instance_data, physicalDevice); auto &call_state = physical_device_state->vkGetPhysicalDeviceSurfacePresentModesKHRState; @@ -9769,7 +9773,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevi VkSurfaceFormatKHR *pSurfaceFormats) { bool skip = false; auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto physical_device_state = GetPhysicalDeviceState(instance_data, physicalDevice); auto &call_state = physical_device_state->vkGetPhysicalDeviceSurfaceFormatsKHRState; @@ -9830,7 +9834,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevi static void PostCallRecordGetPhysicalDeviceSurfaceFormats2KHR(instance_layer_data *instanceData, VkPhysicalDevice physicalDevice, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats) { - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto physicalDeviceState = GetPhysicalDeviceState(instanceData, physicalDevice); if (*pSurfaceFormatCount) { if (physicalDeviceState->vkGetPhysicalDeviceSurfaceFormatsKHRState < QUERY_COUNT) { @@ -9869,7 +9873,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance, instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); VkResult res = instance_data->dispatch_table.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback); if (VK_SUCCESS == res) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); res = layer_create_msg_callback(instance_data->report_data, false, pCreateInfo, pAllocator, pMsgCallback); } return res; @@ -9879,7 +9883,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, Vk const VkAllocationCallbacks *pAllocator) { instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); instance_data->dispatch_table.DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); layer_destroy_msg_callback(instance_data->report_data, msgCallback, pAllocator); } @@ -9984,7 +9988,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device VkResult result = dev_data->dispatch_table.CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); if (VK_SUCCESS == result) { - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); // Shadow template createInfo for later updates safe_VkDescriptorUpdateTemplateCreateInfoKHR *local_create_info = new safe_VkDescriptorUpdateTemplateCreateInfoKHR(pCreateInfo); @@ -9998,7 +10002,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator) { layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); dev_data->desc_template_map.erase(descriptorUpdateTemplate); lock.unlock(); dev_data->dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); @@ -10035,7 +10039,7 @@ VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer c static void PostCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(instance_layer_data *instanceData, VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties) { - std::unique_lock lock(global_lock); + unique_lock_t lock(global_lock); auto physical_device_state = GetPhysicalDeviceState(instanceData, physicalDevice); if (*pPropertyCount) { @@ -10091,7 +10095,7 @@ static bool ValidateGetPhysicalDeviceDisplayPlanePropertiesKHRQuery(instance_lay static bool PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(instance_layer_data *instance_data, VkPhysicalDevice physicalDevice, uint32_t planeIndex) { bool skip = false; - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); skip |= ValidateGetPhysicalDeviceDisplayPlanePropertiesKHRQuery(instance_data, physicalDevice, planeIndex, "vkGetDisplayPlaneSupportedDisplaysKHR"); return skip; @@ -10112,7 +10116,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDev static bool PreCallValidateGetDisplayPlaneCapabilitiesKHR(instance_layer_data *instance_data, VkPhysicalDevice physicalDevice, uint32_t planeIndex) { bool skip = false; - std::lock_guard lock(global_lock); + lock_guard_t lock(global_lock); skip |= ValidateGetPhysicalDeviceDisplayPlanePropertiesKHRQuery(instance_data, physicalDevice, planeIndex, "vkGetDisplayPlaneCapabilitiesKHR"); return skip; -- cgit v1.2.3