From 1b446811ccfee5591931326f28818cfbfa339228 Mon Sep 17 00:00:00 2001 From: Chris Forbes Date: Thu, 29 Sep 2016 14:41:44 +1300 Subject: layers: Combine Destroy{Non,}DispatchableObject These did exactly the same thing, except for the slight wrinkle of needing to cast to uint64_t & in the nondispatchable case to account for MSVC crankiness. We can just do that always. Signed-off-by: Chris Forbes --- layers/object_tracker.cpp | 100 ++++++++++++++-------------------------------- 1 file changed, 29 insertions(+), 71 deletions(-) (limited to 'layers/object_tracker.cpp') diff --git a/layers/object_tracker.cpp b/layers/object_tracker.cpp index a358cc4e..a1f23077 100644 --- a/layers/object_tracker.cpp +++ b/layers/object_tracker.cpp @@ -277,49 +277,7 @@ static void CreateNonDispatchableObject(T1 dispatchable_object, T2 object, VkDeb } template -static void DestroyDispatchableObject(T1 dispatchable_object, T2 object, VkDebugReportObjectTypeEXT object_type, bool custom_allocator) { - layer_data *instance_data = get_my_data_ptr(get_dispatch_key(dispatchable_object), layer_data_map); - - uint64_t object_handle = reinterpret_cast(object); - - // TODO: This function produces errors, but doesn't compose well with either - // a call down the chain or its own state updates - auto item = instance_data->object_map[object_type].find(object_handle); - if (item != instance_data->object_map[object_type].end()) { - - OBJTRACK_NODE *pNode = item->second; - assert(instance_data->num_total_objects > 0); - instance_data->num_total_objects--; - assert(instance_data->num_objects[object_type] > 0); - instance_data->num_objects[pNode->object_type]--; - - log_msg(instance_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, pNode->object_type, object_handle, __LINE__, - OBJTRACK_NONE, LayerName, - "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", - object_name[pNode->object_type], reinterpret_cast(object), instance_data->num_total_objects, - instance_data->num_objects[pNode->object_type], object_name[pNode->object_type]); - - auto allocated_with_custom = pNode->status & OBJSTATUS_CUSTOM_ALLOCATOR; - if (custom_allocator ^ allocated_with_custom) { - log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle, __LINE__, - OBJTRACK_ALLOCATOR_MISMATCH, LayerName, - "Custom allocator %sspecified while destroying %s obj 0x%" PRIxLEAST64 " but %sspecified at creation", - (custom_allocator ? "" : "not "), object_name[object_type], object_handle, - (allocated_with_custom ? "" : "not ")); - } - - delete pNode; - instance_data->object_map[object_type].erase(item); - } else { - log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, object_handle, __LINE__, - OBJTRACK_UNKNOWN_OBJECT, LayerName, - "Unable to remove %s obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?", - object_name[object_type], object_handle); - } -} - -template -static void DestroyNonDispatchableObject(T1 dispatchable_object, T2 object, VkDebugReportObjectTypeEXT object_type, bool custom_allocator) { +static void DestroyObject(T1 dispatchable_object, T2 object, VkDebugReportObjectTypeEXT object_type, bool custom_allocator) { layer_data *device_data = get_my_data_ptr(get_dispatch_key(dispatchable_object), layer_data_map); uint64_t object_handle = reinterpret_cast(object); @@ -424,7 +382,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocati ValidateDispatchableObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, false); - DestroyDispatchableObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, pAllocator); + DestroyObject(instance, instance, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, pAllocator); // Report any remaining objects in LL for (auto iit = instance_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT].begin(); @@ -494,7 +452,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCall std::unique_lock lock(global_lock); ValidateDispatchableObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false); - DestroyDispatchableObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, pAllocator); + DestroyObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, pAllocator); // Report any remaining objects associated with this VkDevice object in LL DeviceReportUndestroyedObjects(device, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT); @@ -886,7 +844,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const Vk } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, fence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, pAllocator); + DestroyObject(device, fence, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyFence(device, fence, pAllocator); } @@ -974,7 +932,7 @@ VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semapho } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, semaphore, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, pAllocator); + DestroyObject(device, semaphore, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroySemaphore(device, semaphore, pAllocator); } @@ -1011,7 +969,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const Vk } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, pAllocator); + DestroyObject(device, event, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyEvent(device, event, pAllocator); } @@ -1090,7 +1048,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPo } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, pAllocator); + DestroyObject(device, queryPool, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyQueryPool(device, queryPool, pAllocator); } @@ -1143,7 +1101,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, pAllocator); + DestroyObject(device, buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyBuffer(device, buffer, pAllocator); } @@ -1183,7 +1141,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView buffe } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, bufferView, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, pAllocator); + DestroyObject(device, bufferView, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyBufferView(device, bufferView, pAllocator); } @@ -1220,7 +1178,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const Vk } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, pAllocator); + DestroyObject(device, image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyImage(device, image, pAllocator); } @@ -1274,7 +1232,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageVi } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, imageView, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, pAllocator); + DestroyObject(device, imageView, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyImageView(device, imageView, pAllocator); } @@ -1313,7 +1271,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule s } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, shaderModule, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, pAllocator); + DestroyObject(device, shaderModule, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyShaderModule(device, shaderModule, pAllocator); } @@ -1352,7 +1310,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, pipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, pAllocator); + DestroyObject(device, pipelineCache, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyPipelineCache(device, pipelineCache, pAllocator); } @@ -1407,7 +1365,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, pipeline, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, pAllocator); + DestroyObject(device, pipeline, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyPipeline(device, pipeline, pAllocator); } @@ -1454,7 +1412,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayo } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, pipelineLayout, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, pAllocator); + DestroyObject(device, pipelineLayout, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyPipelineLayout(device, pipelineLayout, pAllocator); } @@ -1491,7 +1449,7 @@ VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, co } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, sampler, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, pAllocator); + DestroyObject(device, sampler, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroySampler(device, sampler, pAllocator); } @@ -1545,7 +1503,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescrip } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, descriptorSetLayout, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, pAllocator); + DestroyObject(device, descriptorSetLayout, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); } @@ -1700,7 +1658,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer fra } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, framebuffer, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, pAllocator); + DestroyObject(device, framebuffer, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyFramebuffer(device, framebuffer, pAllocator); } @@ -1738,7 +1696,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass rende } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(device, renderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, pAllocator); + DestroyObject(device, renderPass, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, pAllocator); } get_dispatch_table(ot_device_table_map, device)->DestroyRenderPass(device, renderPass, pAllocator); } @@ -2591,7 +2549,7 @@ VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR s } { std::lock_guard lock(global_lock); - DestroyNonDispatchableObject(instance, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, pAllocator); + DestroyObject(instance, surface, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, pAllocator); } get_dispatch_table(ot_instance_table_map, instance)->DestroySurfaceKHR(instance, surface, pAllocator); } @@ -3014,7 +2972,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, Vk pInstanceTable->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); layer_destroy_msg_callback(instance_data->report_data, msgCallback, pAllocator); - DestroyNonDispatchableObject(instance, msgCallback, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, pAllocator); + DestroyObject(instance, msgCallback, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, pAllocator); } VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, @@ -3313,7 +3271,7 @@ VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory memory, co get_dispatch_table(ot_device_table_map, device)->FreeMemory(device, memory, pAllocator); lock.lock(); - DestroyNonDispatchableObject(device, memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, pAllocator); + DestroyObject(device, memory, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, pAllocator); } VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, @@ -3429,7 +3387,7 @@ VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool com } for (uint32_t i = 0; i < commandBufferCount; i++) { - DestroyDispatchableObject(device, pCommandBuffers[i], VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); + DestroyObject(device, pCommandBuffers[i], VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); } lock.unlock(); @@ -3454,7 +3412,7 @@ VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR s ++itr; } } - DestroyNonDispatchableObject(device, swapchain, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, pAllocator); + DestroyObject(device, swapchain, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, pAllocator); lock.unlock(); get_dispatch_table(ot_device_table_map, device)->DestroySwapchainKHR(device, swapchain, pAllocator); @@ -3472,7 +3430,7 @@ VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorP } for (uint32_t i = 0; i < descriptorSetCount; i++) { - DestroyNonDispatchableObject(device, pDescriptorSets[i], VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, false); + DestroyObject(device, pDescriptorSets[i], VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, false); } lock.unlock(); @@ -3503,11 +3461,11 @@ VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPo OBJTRACK_NODE *pNode = (*itr).second; auto del_itr = itr++; if (pNode->parent_object == reinterpret_cast(descriptorPool)) { - DestroyNonDispatchableObject(device, (VkDescriptorSet)((*del_itr).first), + DestroyObject(device, (VkDescriptorSet)((*del_itr).first), VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, false); } } - DestroyNonDispatchableObject(device, descriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, pAllocator); + DestroyObject(device, descriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, pAllocator); lock.unlock(); get_dispatch_table(ot_device_table_map, device)->DestroyDescriptorPool(device, descriptorPool, pAllocator); } @@ -3532,11 +3490,11 @@ VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool com del_itr = itr++; if (pNode->parent_object == reinterpret_cast(commandPool)) { skip_call |= ValidateCommandBuffer(device, commandPool, reinterpret_cast((*del_itr).first)); - DestroyDispatchableObject(device, reinterpret_cast((*del_itr).first), + DestroyObject(device, reinterpret_cast((*del_itr).first), VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false); } } - DestroyNonDispatchableObject(device, commandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, pAllocator); + DestroyObject(device, commandPool, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, pAllocator); lock.unlock(); get_dispatch_table(ot_device_table_map, device)->DestroyCommandPool(device, commandPool, pAllocator); } -- cgit v1.2.3