/* Copyright (c) 2015-2016 The Khronos Group Inc. * Copyright (c) 2015-2016 Valve Corporation * Copyright (c) 2015-2016 LunarG, Inc. * Copyright (C) 2015-2016 Google Inc. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and/or associated documentation files (the "Materials"), to * deal in the Materials without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Materials, and to permit persons to whom the Materials * are furnished to do so, subject to the following conditions: * * The above copyright notice(s) and this permission notice shall be included * in all copies or substantial portions of the Materials. * * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE * USE OR OTHER DEALINGS IN THE MATERIALS * * Author: Cody Northrop * Author: Jon Ashburn * Author: Mark Lobodzinski * Author: Tobin Ehlis */ #include #include #include #include #include #include #include #include #include using namespace std; #include "vk_loader_platform.h" #include "vk_dispatch_table_helper.h" #include "vk_struct_string_helper_cpp.h" #include "mem_tracker.h" #include "vk_layer_config.h" #include "vk_layer_extension_utils.h" #include "vk_layer_table.h" #include "vk_layer_data.h" #include "vk_layer_logging.h" // WSI Image Objects bypass usual Image Object creation methods. A special Memory // Object value will be used to identify them internally. static const VkDeviceMemory MEMTRACKER_SWAP_CHAIN_IMAGE_KEY = (VkDeviceMemory)(-1); struct layer_data { debug_report_data *report_data; std::vector logging_callback; VkLayerDispatchTable *device_dispatch_table; VkLayerInstanceDispatchTable *instance_dispatch_table; VkBool32 wsi_enabled; uint64_t currentFenceId; VkPhysicalDeviceProperties properties; unordered_map> bufferRanges, imageRanges; // Maps for tracking key structs related to MemTracker state unordered_map cbMap; unordered_map commandPoolMap; unordered_map memObjMap; unordered_map fenceMap; unordered_map queueMap; unordered_map swapchainMap; unordered_map semaphoreMap; unordered_map fbMap; unordered_map passMap; unordered_map imageViewMap; unordered_map descriptorSetMap; // Images and Buffers are 2 objects that can have memory bound to them so they get special treatment unordered_map imageMap; unordered_map bufferMap; layer_data() : report_data(nullptr), device_dispatch_table(nullptr), instance_dispatch_table(nullptr), wsi_enabled(VK_FALSE), currentFenceId(1) {}; }; static unordered_map layer_data_map; static VkPhysicalDeviceMemoryProperties memProps; static VkBool32 clear_cmd_buf_and_mem_references(layer_data* my_data, const VkCommandBuffer cb); // TODO : This can be much smarter, using separate locks for separate global data static int globalLockInitialized = 0; static loader_platform_thread_mutex globalLock; #define MAX_BINDING 0xFFFFFFFF static MT_OBJ_BINDING_INFO* get_object_binding_info( layer_data *my_data, uint64_t handle, VkDebugReportObjectTypeEXT type) { MT_OBJ_BINDING_INFO* retValue = NULL; switch (type) { case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: { auto it = my_data->imageMap.find(handle); if (it != my_data->imageMap.end()) return &(*it).second; break; } case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: { auto it = my_data->bufferMap.find(handle); if (it != my_data->bufferMap.end()) return &(*it).second; break; } default: break; } return retValue; } template layer_data *get_my_data_ptr( void *data_key, std::unordered_map &data_map); // Add new queue for this device to map container static void add_queue_info( layer_data *my_data, const VkQueue queue) { MT_QUEUE_INFO* pInfo = &my_data->queueMap[queue]; pInfo->lastRetiredId = 0; pInfo->lastSubmittedId = 0; } static void delete_queue_info_list( layer_data* my_data) { // Process queue list, cleaning up each entry before deleting my_data->queueMap.clear(); } static void add_swap_chain_info( layer_data *my_data, const VkSwapchainKHR swapchain, const VkSwapchainCreateInfoKHR *pCI) { MT_SWAP_CHAIN_INFO* pInfo = new MT_SWAP_CHAIN_INFO; memcpy(&pInfo->createInfo, pCI, sizeof(VkSwapchainCreateInfoKHR)); my_data->swapchainMap[swapchain] = pInfo; } // Add new CBInfo for this cb to map container static void add_cmd_buf_info( layer_data *my_data, VkCommandPool commandPool, const VkCommandBuffer cb) { my_data->cbMap[cb].commandBuffer = cb; my_data->commandPoolMap[commandPool].pCommandBuffers.push_front(cb); } // Delete CBInfo from container and clear mem references to CB static VkBool32 delete_cmd_buf_info( layer_data *my_data, VkCommandPool commandPool, const VkCommandBuffer cb) { VkBool32 result = VK_TRUE; result = clear_cmd_buf_and_mem_references(my_data, cb); // Delete the CBInfo info if (result != VK_TRUE) { my_data->commandPoolMap[commandPool].pCommandBuffers.remove(cb); my_data->cbMap.erase(cb); } return result; } // Return ptr to Info in CB map, or NULL if not found static MT_CB_INFO* get_cmd_buf_info( layer_data *my_data, const VkCommandBuffer cb) { auto item = my_data->cbMap.find(cb); if (item != my_data->cbMap.end()) { return &(*item).second; } else { return NULL; } } static void add_object_binding_info( layer_data *my_data, const uint64_t handle, const VkDebugReportObjectTypeEXT type, const VkDeviceMemory mem) { switch (type) { // Buffers and images are unique as their CreateInfo is in container struct case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: { auto pCI = &my_data->bufferMap[handle]; pCI->mem = mem; break; } case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: { auto pCI = &my_data->imageMap[handle]; pCI->mem = mem; break; } default: break; } } static void add_object_create_info( layer_data *my_data, const uint64_t handle, const VkDebugReportObjectTypeEXT type, const void *pCreateInfo) { // TODO : For any CreateInfo struct that has ptrs, need to deep copy them and appropriately clean up on Destroy switch (type) { // Buffers and images are unique as their CreateInfo is in container struct case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: { auto pCI = &my_data->bufferMap[handle]; memset(pCI, 0, sizeof(MT_OBJ_BINDING_INFO)); memcpy(&pCI->create_info.buffer, pCreateInfo, sizeof(VkBufferCreateInfo)); break; } case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: { auto pCI = &my_data->imageMap[handle]; memset(pCI, 0, sizeof(MT_OBJ_BINDING_INFO)); memcpy(&pCI->create_info.image, pCreateInfo, sizeof(VkImageCreateInfo)); break; } // Swap Chain is very unique, use my_data->imageMap, but copy in // SwapChainCreatInfo's usage flags and set the mem value to a unique key. These is used by // vkCreateImageView and internal MemTracker routines to distinguish swap chain images case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT: { auto pCI = &my_data->imageMap[handle]; memset(pCI, 0, sizeof(MT_OBJ_BINDING_INFO)); pCI->mem = MEMTRACKER_SWAP_CHAIN_IMAGE_KEY; pCI->valid = false; pCI->create_info.image.usage = const_cast(static_cast(pCreateInfo))->imageUsage; break; } default: break; } } // Add a fence, creating one if necessary to our list of fences/fenceIds static VkBool32 add_fence_info( layer_data *my_data, VkFence fence, VkQueue queue, uint64_t *fenceId) { VkBool32 skipCall = VK_FALSE; *fenceId = my_data->currentFenceId++; // If no fence, create an internal fence to track the submissions if (fence != VK_NULL_HANDLE) { my_data->fenceMap[fence].fenceId = *fenceId; my_data->fenceMap[fence].queue = queue; // Validate that fence is in UNSIGNALED state VkFenceCreateInfo* pFenceCI = &(my_data->fenceMap[fence].createInfo); if (pFenceCI->flags & VK_FENCE_CREATE_SIGNALED_BIT) { skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, (uint64_t) fence, __LINE__, MEMTRACK_INVALID_FENCE_STATE, "MEM", "Fence %#" PRIxLEAST64 " submitted in SIGNALED state. Fences must be reset before being submitted", (uint64_t) fence); } } else { // TODO : Do we need to create an internal fence here for tracking purposes? } // Update most recently submitted fence and fenceId for Queue my_data->queueMap[queue].lastSubmittedId = *fenceId; 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); if (fence_item != my_data->fenceMap.end()) { MT_FENCE_INFO *pCurFenceInfo = &(*fence_item).second; VkQueue queue = pCurFenceInfo->queue; auto queue_item = my_data->queueMap.find(queue); if (queue_item != my_data->queueMap.end()) { MT_QUEUE_INFO *pQueueInfo = &(*queue_item).second; if (pQueueInfo->lastRetiredId < pCurFenceInfo->fenceId) { pQueueInfo->lastRetiredId = pCurFenceInfo->fenceId; } } } // Update fence state in fenceCreateInfo structure auto pFCI = &(my_data->fenceMap[fence].createInfo); pFCI->flags = static_cast(pFCI->flags | VK_FENCE_CREATE_SIGNALED_BIT); } // Helper routine that updates the fence list for a specific queue to all-retired static void retire_queue_fences( layer_data *my_data, VkQueue queue) { MT_QUEUE_INFO *pQueueInfo = &my_data->queueMap[queue]; // Set queue's lastRetired to lastSubmitted indicating all fences completed pQueueInfo->lastRetiredId = pQueueInfo->lastSubmittedId; } // Helper routine that updates all queues to all-retired static void retire_device_fences( layer_data *my_data, VkDevice device) { // Process each queue for device // TODO: Add multiple device support for (auto ii=my_data->queueMap.begin(); ii!=my_data->queueMap.end(); ++ii) { // Set queue's lastRetired to lastSubmitted indicating all fences completed MT_QUEUE_INFO *pQueueInfo = &(*ii).second; pQueueInfo->lastRetiredId = pQueueInfo->lastSubmittedId; } } // Helper function to validate correct usage bits set for buffers or images // Verify that (actual & desired) flags != 0 or, // if strict is true, verify that (actual & desired) flags == desired // In case of error, report it via dbg callbacks static VkBool32 validate_usage_flags( layer_data *my_data, void *disp_obj, VkFlags actual, VkFlags desired, VkBool32 strict, uint64_t obj_handle, VkDebugReportObjectTypeEXT obj_type, char const *ty_str, char const *func_name, char const *usage_str) { VkBool32 correct_usage = VK_FALSE; VkBool32 skipCall = VK_FALSE; if (strict) correct_usage = ((actual & desired) == desired); else correct_usage = ((actual & desired) != 0); if (!correct_usage) { skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, obj_type, obj_handle, __LINE__, MEMTRACK_INVALID_USAGE_FLAG, "MEM", "Invalid usage flag for %s %#" PRIxLEAST64 " used by %s. In this case, %s should have %s set during creation.", ty_str, obj_handle, func_name, ty_str, usage_str); } return skipCall; } // Helper function to validate usage flags for images // Pulls image info and then sends actual vs. desired usage off to helper above where // an error will be flagged if usage is not correct static VkBool32 validate_image_usage_flags( layer_data *my_data, void *disp_obj, VkImage image, VkFlags desired, VkBool32 strict, char const *func_name, char const *usage_string) { VkBool32 skipCall = VK_FALSE; MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(my_data, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT); if (pBindInfo) { skipCall = validate_usage_flags(my_data, disp_obj, pBindInfo->create_info.image.usage, desired, strict, (uint64_t) image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "image", func_name, usage_string); } return skipCall; } // Helper function to validate usage flags for buffers // Pulls buffer info and then sends actual vs. desired usage off to helper above where // an error will be flagged if usage is not correct static VkBool32 validate_buffer_usage_flags( layer_data *my_data, void *disp_obj, VkBuffer buffer, VkFlags desired, VkBool32 strict, char const *func_name, char const *usage_string) { VkBool32 skipCall = VK_FALSE; MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(my_data, (uint64_t) buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT); if (pBindInfo) { skipCall = validate_usage_flags(my_data, disp_obj, pBindInfo->create_info.buffer.usage, desired, strict, (uint64_t) buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "buffer", func_name, usage_string); } return skipCall; } // Return ptr to info in map container containing mem, or NULL if not found // Calls to this function should be wrapped in mutex static MT_MEM_OBJ_INFO* get_mem_obj_info( layer_data *my_data, const VkDeviceMemory mem) { auto item = my_data->memObjMap.find(mem); if (item != my_data->memObjMap.end()) { return &(*item).second; } else { return NULL; } } static void add_mem_obj_info( layer_data *my_data, void *object, const VkDeviceMemory mem, const VkMemoryAllocateInfo *pAllocateInfo) { assert(object != NULL); memcpy(&my_data->memObjMap[mem].allocInfo, pAllocateInfo, sizeof(VkMemoryAllocateInfo)); // TODO: Update for real hardware, actually process allocation info structures my_data->memObjMap[mem].allocInfo.pNext = NULL; my_data->memObjMap[mem].object = object; my_data->memObjMap[mem].refCount = 0; my_data->memObjMap[mem].mem = mem; my_data->memObjMap[mem].memRange.offset = 0; my_data->memObjMap[mem].memRange.size = 0; my_data->memObjMap[mem].pData = 0; my_data->memObjMap[mem].pDriverData = 0; my_data->memObjMap[mem].valid = false; } static VkBool32 validate_memory_is_valid(layer_data *my_data, VkDeviceMemory mem, const char* functionName, VkImage image = VK_NULL_HANDLE) { if (mem == MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) { MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(my_data, (uint64_t)(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT); if (pBindInfo && !pBindInfo->valid) { return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)(mem), __LINE__, MEMTRACK_INVALID_USAGE_FLAG, "MEM", "%s: Cannot read invalid swapchain image %" PRIx64 ", please fill the memory before using.", functionName, (uint64_t)(image)); } } else { MT_MEM_OBJ_INFO *pMemObj = get_mem_obj_info(my_data, mem); if (pMemObj && !pMemObj->valid) { return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)(mem), __LINE__, MEMTRACK_INVALID_USAGE_FLAG, "MEM", "%s: Cannot read invalid memory %" PRIx64 ", please fill the memory before using.", functionName, (uint64_t)(mem)); } } return false; } static void set_memory_valid(layer_data *my_data, VkDeviceMemory mem, bool valid, VkImage image = VK_NULL_HANDLE) { if (mem == MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) { MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(my_data, (uint64_t)(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT); if (pBindInfo) { pBindInfo->valid = valid; } } else { MT_MEM_OBJ_INFO *pMemObj = get_mem_obj_info(my_data, mem); if (pMemObj) { pMemObj->valid = valid; } } } // Find CB Info and add mem reference to list container // Find Mem Obj Info and add CB reference to list container static VkBool32 update_cmd_buf_and_mem_references( layer_data *my_data, const VkCommandBuffer cb, const VkDeviceMemory mem, const char *apiName) { VkBool32 skipCall = VK_FALSE; // Skip validation if this image was created through WSI if (mem != MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) { // First update CB binding in MemObj mini CB list MT_MEM_OBJ_INFO* pMemInfo = get_mem_obj_info(my_data, mem); if (pMemInfo) { // Search for cmd buffer object in memory object's binding list VkBool32 found = VK_FALSE; if (pMemInfo->pCommandBufferBindings.size() > 0) { for (list::iterator it = pMemInfo->pCommandBufferBindings.begin(); it != pMemInfo->pCommandBufferBindings.end(); ++it) { if ((*it) == cb) { found = VK_TRUE; break; } } } // If not present, add to list if (found == VK_FALSE) { pMemInfo->pCommandBufferBindings.push_front(cb); pMemInfo->refCount++; } // Now update CBInfo's Mem reference list MT_CB_INFO* pCBInfo = get_cmd_buf_info(my_data, cb); // TODO: keep track of all destroyed CBs so we know if this is a stale or simply invalid object if (pCBInfo) { // Search for memory object in cmd buffer's reference list VkBool32 found = VK_FALSE; if (pCBInfo->pMemObjList.size() > 0) { for (auto it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { if ((*it) == mem) { found = VK_TRUE; break; } } } // If not present, add to list if (found == VK_FALSE) { pCBInfo->pMemObjList.push_front(mem); } } } } return skipCall; } // Free bindings related to CB static VkBool32 clear_cmd_buf_and_mem_references( layer_data *my_data, const VkCommandBuffer cb) { VkBool32 skipCall = VK_FALSE; MT_CB_INFO* pCBInfo = get_cmd_buf_info(my_data, cb); if (pCBInfo && (pCBInfo->pMemObjList.size() > 0)) { list mem_obj_list = pCBInfo->pMemObjList; for (list::iterator it=mem_obj_list.begin(); it!=mem_obj_list.end(); ++it) { MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(my_data, *it); if (pInfo) { pInfo->pCommandBufferBindings.remove(cb); pInfo->refCount--; } } pCBInfo->pMemObjList.clear(); pCBInfo->activeDescriptorSets.clear(); pCBInfo->validate_functions.clear(); } return skipCall; } // Delete the entire CB list static VkBool32 delete_cmd_buf_info_list( layer_data* my_data) { VkBool32 skipCall = VK_FALSE; for (unordered_map::iterator ii=my_data->cbMap.begin(); ii!=my_data->cbMap.end(); ++ii) { skipCall |= clear_cmd_buf_and_mem_references(my_data, (*ii).first); } my_data->cbMap.clear(); return skipCall; } // For given MemObjInfo, report Obj & CB bindings static VkBool32 reportMemReferencesAndCleanUp( layer_data *my_data, MT_MEM_OBJ_INFO *pMemObjInfo) { VkBool32 skipCall = VK_FALSE; size_t cmdBufRefCount = pMemObjInfo->pCommandBufferBindings.size(); size_t objRefCount = pMemObjInfo->pObjBindings.size(); if ((pMemObjInfo->pCommandBufferBindings.size()) != 0) { skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t) pMemObjInfo->mem, __LINE__, MEMTRACK_FREED_MEM_REF, "MEM", "Attempting to free memory object %#" PRIxLEAST64 " which still contains " PRINTF_SIZE_T_SPECIFIER " references", (uint64_t) pMemObjInfo->mem, (cmdBufRefCount + objRefCount)); } if (cmdBufRefCount > 0 && pMemObjInfo->pCommandBufferBindings.size() > 0) { for (list::const_iterator it = pMemObjInfo->pCommandBufferBindings.begin(); it != pMemObjInfo->pCommandBufferBindings.end(); ++it) { // TODO : CommandBuffer should be source Obj here log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)(*it), __LINE__, MEMTRACK_FREED_MEM_REF, "MEM", "Command Buffer %p still has a reference to mem obj %#" PRIxLEAST64, (*it), (uint64_t) pMemObjInfo->mem); } // Clear the list of hanging references pMemObjInfo->pCommandBufferBindings.clear(); } if (objRefCount > 0 && pMemObjInfo->pObjBindings.size() > 0) { for (auto it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) { log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, it->type, it->handle, __LINE__, MEMTRACK_FREED_MEM_REF, "MEM", "VK Object %#" PRIxLEAST64 " still has a reference to mem obj %#" PRIxLEAST64, it->handle, (uint64_t) pMemObjInfo->mem); } // Clear the list of hanging references pMemObjInfo->pObjBindings.clear(); } return skipCall; } static VkBool32 deleteMemObjInfo( layer_data *my_data, void *object, VkDeviceMemory mem) { VkBool32 skipCall = VK_FALSE; auto item = my_data->memObjMap.find(mem); if (item != my_data->memObjMap.end()) { my_data->memObjMap.erase(item); } else { skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t) mem, __LINE__, MEMTRACK_INVALID_MEM_OBJ, "MEM", "Request to delete memory object %#" PRIxLEAST64 " not present in memory Object Map", (uint64_t) mem); } return skipCall; } // Check if fence for given CB is completed static VkBool32 checkCBCompleted( layer_data *my_data, const VkCommandBuffer cb, VkBool32 *complete) { MT_CB_INFO *pCBInfo = get_cmd_buf_info(my_data, cb); VkBool32 skipCall = VK_FALSE; *complete = VK_TRUE; if (pCBInfo) { if (pCBInfo->lastSubmittedQueue != NULL) { VkQueue queue = pCBInfo->lastSubmittedQueue; MT_QUEUE_INFO *pQueueInfo = &my_data->queueMap[queue]; if (pCBInfo->fenceId > pQueueInfo->lastRetiredId) { skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)cb, __LINE__, MEMTRACK_NONE, "MEM", "fence %#" PRIxLEAST64 " for CB %p has not been checked for completion", (uint64_t) pCBInfo->lastSubmittedFence, cb); *complete = VK_FALSE; } } } return skipCall; } static VkBool32 freeMemObjInfo( layer_data *my_data, void* object, VkDeviceMemory mem, VkBool32 internal) { VkBool32 skipCall = VK_FALSE; // Parse global list to find info w/ mem MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(my_data, mem); if (pInfo) { if (pInfo->allocInfo.allocationSize == 0 && !internal) { // TODO: Verify against Valid Use section skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t) mem, __LINE__, MEMTRACK_INVALID_MEM_OBJ, "MEM", "Attempting to free memory associated with a Persistent Image, %#" PRIxLEAST64 ", " "this should not be explicitly freed\n", (uint64_t) mem); } else { // Clear any CB bindings for completed CBs // TODO : Is there a better place to do this? VkBool32 commandBufferComplete = VK_FALSE; assert(pInfo->object != VK_NULL_HANDLE); list::iterator it = pInfo->pCommandBufferBindings.begin(); list::iterator temp; while (pInfo->pCommandBufferBindings.size() > 0 && it != pInfo->pCommandBufferBindings.end()) { skipCall |= checkCBCompleted(my_data, *it, &commandBufferComplete); if (VK_TRUE == commandBufferComplete) { temp = it; ++temp; skipCall |= clear_cmd_buf_and_mem_references(my_data, *it); it = temp; } else { ++it; } } // Now verify that no references to this mem obj remain and remove bindings if (0 != pInfo->refCount) { skipCall |= reportMemReferencesAndCleanUp(my_data, pInfo); } // Delete mem obj info skipCall |= deleteMemObjInfo(my_data, object, mem); } } return skipCall; } static const char* object_type_to_string( VkDebugReportObjectTypeEXT type) { switch (type) { case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: return "image"; break; case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: return "buffer"; break; case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT: return "swapchain"; break; default: return "unknown"; } } // Remove object binding performs 3 tasks: // 1. Remove ObjectInfo from MemObjInfo list container of obj bindings & free it // 2. Decrement refCount for MemObjInfo // 3. Clear mem binding for image/buffer by setting its handle to 0 // TODO : This only applied to Buffer, Image, and Swapchain objects now, how should it be updated/customized? static VkBool32 clear_object_binding( layer_data *my_data, void *dispObj, uint64_t handle, VkDebugReportObjectTypeEXT type) { // TODO : Need to customize images/buffers/swapchains to track mem binding and clear it here appropriately VkBool32 skipCall = VK_FALSE; MT_OBJ_BINDING_INFO* pObjBindInfo = get_object_binding_info(my_data, handle, type); if (pObjBindInfo) { MT_MEM_OBJ_INFO* pMemObjInfo = get_mem_obj_info(my_data, pObjBindInfo->mem); // TODO : Make sure this is a reasonable way to reset mem binding pObjBindInfo->mem = VK_NULL_HANDLE; if (pMemObjInfo) { // This obj is bound to a memory object. Remove the reference to this object in that memory object's list, decrement the memObj's refcount // and set the objects memory binding pointer to NULL. VkBool32 clearSucceeded = VK_FALSE; for (auto it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) { if ((it->handle == handle) && (it->type == type)) { pMemObjInfo->refCount--; pMemObjInfo->pObjBindings.erase(it); clearSucceeded = VK_TRUE; break; } } if (VK_FALSE == clearSucceeded ) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_OBJECT, "MEM", "While trying to clear mem binding for %s obj %#" PRIxLEAST64 ", unable to find that object referenced by mem obj %#" PRIxLEAST64, object_type_to_string(type), handle, (uint64_t) pMemObjInfo->mem); } } } return skipCall; } // For NULL mem case, output warning // Make sure given object is in global object map // IF a previous binding existed, output validation error // Otherwise, add reference from objectInfo to memoryInfo // Add reference off of objInfo // device is required for error logging, need a dispatchable // object for that. static VkBool32 set_mem_binding( layer_data *my_data, void *dispatch_object, VkDeviceMemory mem, uint64_t handle, VkDebugReportObjectTypeEXT type, const char *apiName) { VkBool32 skipCall = VK_FALSE; // Handle NULL case separately, just clear previous binding & decrement reference if (mem == VK_NULL_HANDLE) { // TODO: Verify against Valid Use section of spec. skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_MEM_OBJ, "MEM", "In %s, attempting to Bind Obj(%#" PRIxLEAST64 ") to NULL", apiName, handle); } else { MT_OBJ_BINDING_INFO* pObjBindInfo = get_object_binding_info(my_data, handle, type); if (!pObjBindInfo) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", "In %s, attempting to update Binding of %s Obj(%#" PRIxLEAST64 ") that's not in global list()", object_type_to_string(type), apiName, handle); } else { // non-null case so should have real mem obj MT_MEM_OBJ_INFO* pMemInfo = get_mem_obj_info(my_data, mem); if (pMemInfo) { // TODO : Need to track mem binding for obj and report conflict here MT_MEM_OBJ_INFO* pPrevBinding = get_mem_obj_info(my_data, pObjBindInfo->mem); if (pPrevBinding != NULL) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t) mem, __LINE__, MEMTRACK_REBIND_OBJECT, "MEM", "In %s, attempting to bind memory (%#" PRIxLEAST64 ") to object (%#" PRIxLEAST64 ") which has already been bound to mem object %#" PRIxLEAST64, apiName, (uint64_t) mem, handle, (uint64_t) pPrevBinding->mem); } else { MT_OBJ_HANDLE_TYPE oht; oht.handle = handle; oht.type = type; pMemInfo->pObjBindings.push_front(oht); pMemInfo->refCount++; // For image objects, make sure default memory state is correctly set // TODO : What's the best/correct way to handle this? if (VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT == type) { VkImageCreateInfo ici = pObjBindInfo->create_info.image; if (ici.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) { // TODO:: More memory state transition stuff. } } pObjBindInfo->mem = mem; } } } } return skipCall; } // For NULL mem case, clear any previous binding Else... // Make sure given object is in its object map // IF a previous binding existed, update binding // Add reference from objectInfo to memoryInfo // Add reference off of object's binding info // Return VK_TRUE if addition is successful, VK_FALSE otherwise static VkBool32 set_sparse_mem_binding( layer_data *my_data, void *dispObject, VkDeviceMemory mem, uint64_t handle, VkDebugReportObjectTypeEXT type, const char *apiName) { VkBool32 skipCall = VK_FALSE; // Handle NULL case separately, just clear previous binding & decrement reference if (mem == VK_NULL_HANDLE) { skipCall = clear_object_binding(my_data, dispObject, handle, type); } else { MT_OBJ_BINDING_INFO* pObjBindInfo = get_object_binding_info(my_data, handle, type); if (!pObjBindInfo) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", "In %s, attempting to update Binding of Obj(%#" PRIxLEAST64 ") that's not in global list()", apiName, handle); } // non-null case so should have real mem obj MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(my_data, mem); if (pInfo) { // Search for object in memory object's binding list VkBool32 found = VK_FALSE; if (pInfo->pObjBindings.size() > 0) { for (auto it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) { if (((*it).handle == handle) && ((*it).type == type)) { found = VK_TRUE; break; } } } // If not present, add to list if (found == VK_FALSE) { MT_OBJ_HANDLE_TYPE oht; oht.handle = handle; oht.type = type; pInfo->pObjBindings.push_front(oht); pInfo->refCount++; } // Need to set mem binding for this object pObjBindInfo->mem = mem; } } return skipCall; } template void print_object_map_members( layer_data *my_data, void *dispObj, T const& objectName, VkDebugReportObjectTypeEXT objectType, const char *objectStr) { for (auto const& element : objectName) { log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, objectType, 0, __LINE__, MEMTRACK_NONE, "MEM", " %s Object list contains %s Object %#" PRIxLEAST64 " ", objectStr, objectStr, element.first); } } // For given Object, get 'mem' obj that it's bound to or NULL if no binding static VkBool32 get_mem_binding_from_object( layer_data *my_data, void *dispObj, const uint64_t handle, const VkDebugReportObjectTypeEXT type, VkDeviceMemory *mem) { VkBool32 skipCall = VK_FALSE; *mem = VK_NULL_HANDLE; MT_OBJ_BINDING_INFO* pObjBindInfo = get_object_binding_info(my_data, handle, type); if (pObjBindInfo) { if (pObjBindInfo->mem) { *mem = pObjBindInfo->mem; } else { skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", "Trying to get mem binding for object %#" PRIxLEAST64 " but object has no mem binding", handle); } } else { skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_OBJECT, "MEM", "Trying to get mem binding for object %#" PRIxLEAST64 " but no such object in %s list", handle, object_type_to_string(type)); } return skipCall; } // Print details of MemObjInfo list static void print_mem_list( layer_data *my_data, void *dispObj) { MT_MEM_OBJ_INFO* pInfo = NULL; // Early out if info is not requested if (!(my_data->report_data->active_flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)) { return; } // Just printing each msg individually for now, may want to package these into single large print log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", "Details of Memory Object list (of size " PRINTF_SIZE_T_SPECIFIER " elements)", my_data->memObjMap.size()); log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", "============================="); if (my_data->memObjMap.size() <= 0) return; for (auto ii=my_data->memObjMap.begin(); ii!=my_data->memObjMap.end(); ++ii) { pInfo = &(*ii).second; log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " ===MemObjInfo at %p===", (void*)pInfo); log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " Mem object: %#" PRIxLEAST64, (uint64_t)(pInfo->mem)); log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " Ref Count: %u", pInfo->refCount); if (0 != pInfo->allocInfo.allocationSize) { string pAllocInfoMsg = vk_print_vkmemoryallocateinfo(&pInfo->allocInfo, "MEM(INFO): "); log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " Mem Alloc info:\n%s", pAllocInfoMsg.c_str()); } else { log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " Mem Alloc info is NULL (alloc done by vkCreateSwapchainKHR())"); } log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " VK OBJECT Binding list of size " PRINTF_SIZE_T_SPECIFIER " elements:", pInfo->pObjBindings.size()); if (pInfo->pObjBindings.size() > 0) { for (list::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) { log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " VK OBJECT %" PRIu64, it->handle); } } log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " VK Command Buffer (CB) binding list of size " PRINTF_SIZE_T_SPECIFIER " elements", pInfo->pCommandBufferBindings.size()); if (pInfo->pCommandBufferBindings.size() > 0) { for (list::iterator it = pInfo->pCommandBufferBindings.begin(); it != pInfo->pCommandBufferBindings.end(); ++it) { log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " VK CB %p", (*it)); } } } } static void printCBList( layer_data *my_data, void *dispObj) { MT_CB_INFO* pCBInfo = NULL; // Early out if info is not requested if (!(my_data->report_data->active_flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)) { return; } log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", "Details of CB list (of size " PRINTF_SIZE_T_SPECIFIER " elements)", my_data->cbMap.size()); log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", "=================="); if (my_data->cbMap.size() <= 0) return; for (auto ii=my_data->cbMap.begin(); ii!=my_data->cbMap.end(); ++ii) { pCBInfo = &(*ii).second; log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " CB Info (%p) has CB %p, fenceId %" PRIx64", and fence %#" PRIxLEAST64, (void*)pCBInfo, (void*)pCBInfo->commandBuffer, pCBInfo->fenceId, (uint64_t) pCBInfo->lastSubmittedFence); if (pCBInfo->pMemObjList.size() <= 0) continue; for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " Mem obj %" PRIu64, (uint64_t)(*it)); } } } static void init_mem_tracker( layer_data *my_data, const VkAllocationCallbacks *pAllocator) { uint32_t report_flags = 0; uint32_t debug_action = 0; FILE *log_output = NULL; const char *option_str; VkDebugReportCallbackEXT callback; // initialize MemTracker options report_flags = getLayerOptionFlags("MemTrackerReportFlags", 0); getLayerOptionEnum("MemTrackerDebugAction", (uint32_t *) &debug_action); if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG) { option_str = getLayerOption("MemTrackerLogFilename"); log_output = getLayerLogOutput(option_str, "MemTracker"); VkDebugReportCallbackCreateInfoEXT dbgInfo; memset(&dbgInfo, 0, sizeof(dbgInfo)); dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT; dbgInfo.pfnCallback = log_callback; dbgInfo.pUserData = log_output; dbgInfo.flags = report_flags; layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &callback); my_data->logging_callback.push_back(callback); } if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) { VkDebugReportCallbackCreateInfoEXT dbgInfo; memset(&dbgInfo, 0, sizeof(dbgInfo)); dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT; dbgInfo.pfnCallback = win32_debug_output_msg; dbgInfo.pUserData = log_output; dbgInfo.flags = report_flags; layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &callback); my_data->logging_callback.push_back(callback); } if (!globalLockInitialized) { loader_platform_thread_create_mutex(&globalLock); globalLockInitialized = 1; } // Zero out memory property data memset(&memProps, 0, sizeof(VkPhysicalDeviceMemoryProperties)); } // hook DestroyInstance to remove tableInstanceMap entry VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks *pAllocator) { // Grab the key before the instance is destroyed. dispatch_key key = get_dispatch_key(instance); layer_data *my_data = get_my_data_ptr(key, layer_data_map); VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table; pTable->DestroyInstance(instance, pAllocator); loader_platform_thread_lock_mutex(&globalLock); // Clean up logging callback, if any while (my_data->logging_callback.size() > 0) { VkDebugReportCallbackEXT callback = my_data->logging_callback.back(); layer_destroy_msg_callback(my_data->report_data, callback, pAllocator); my_data->logging_callback.pop_back(); } layer_debug_report_destroy_instance(my_data->report_data); delete my_data->instance_dispatch_table; layer_data_map.erase(key); loader_platform_thread_unlock_mutex(&globalLock); if (layer_data_map.empty()) { // Release mutex when destroying last instance loader_platform_thread_delete_mutex(&globalLock); globalLockInitialized = 0; } } VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); assert(chain_info->u.pLayerInfo); PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance) fpGetInstanceProcAddr(NULL, "vkCreateInstance"); if (fpCreateInstance == NULL) { return VK_ERROR_INITIALIZATION_FAILED; } // Advance the link info for the next element on the chain chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance); if (result != VK_SUCCESS) { return result; } layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map); my_data->instance_dispatch_table = new VkLayerInstanceDispatchTable; layer_init_instance_dispatch_table(*pInstance, my_data->instance_dispatch_table, fpGetInstanceProcAddr); my_data->report_data = debug_report_create_instance( my_data->instance_dispatch_table, *pInstance, pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames); init_mem_tracker(my_data, pAllocator); return result; } static void createDeviceRegisterExtensions( const VkDeviceCreateInfo *pCreateInfo, VkDevice device) { layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkLayerDispatchTable *pDisp = my_device_data->device_dispatch_table; PFN_vkGetDeviceProcAddr gpa = pDisp->GetDeviceProcAddr; pDisp->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) gpa(device, "vkCreateSwapchainKHR"); pDisp->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) gpa(device, "vkDestroySwapchainKHR"); pDisp->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) gpa(device, "vkGetSwapchainImagesKHR"); pDisp->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) gpa(device, "vkAcquireNextImageKHR"); pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(device, "vkQueuePresentKHR"); my_device_data->wsi_enabled = VK_FALSE; for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) my_device_data->wsi_enabled = true; } } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); assert(chain_info->u.pLayerInfo); PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice) fpGetInstanceProcAddr(NULL, "vkCreateDevice"); if (fpCreateDevice == NULL) { return VK_ERROR_INITIALIZATION_FAILED; } // Advance the link info for the next element on the chain chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; VkResult result = fpCreateDevice(gpu, pCreateInfo, pAllocator, pDevice); if (result != VK_SUCCESS) { return result; } layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map); layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map); // Setup device dispatch table my_device_data->device_dispatch_table = new VkLayerDispatchTable; layer_init_device_dispatch_table(*pDevice, my_device_data->device_dispatch_table, fpGetDeviceProcAddr); my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice); createDeviceRegisterExtensions(pCreateInfo, *pDevice); my_instance_data->instance_dispatch_table->GetPhysicalDeviceProperties(gpu, &my_device_data->properties); return result; } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( VkDevice device, const VkAllocationCallbacks *pAllocator) { dispatch_key key = get_dispatch_key(device); layer_data *my_device_data = get_my_data_ptr(key, layer_data_map); VkBool32 skipCall = VK_FALSE; loader_platform_thread_lock_mutex(&globalLock); log_msg(my_device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, (uint64_t)device, __LINE__, MEMTRACK_NONE, "MEM", "Printing List details prior to vkDestroyDevice()"); log_msg(my_device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, (uint64_t)device, __LINE__, MEMTRACK_NONE, "MEM", "================================================"); print_mem_list(my_device_data, device); printCBList(my_device_data, device); skipCall = delete_cmd_buf_info_list(my_device_data); // Report any memory leaks MT_MEM_OBJ_INFO* pInfo = NULL; if (my_device_data->memObjMap.size() > 0) { for (auto ii=my_device_data->memObjMap.begin(); ii!=my_device_data->memObjMap.end(); ++ii) { pInfo = &(*ii).second; if (pInfo->allocInfo.allocationSize != 0) { // Valid Usage: All child objects created on device must have been destroyed prior to destroying device skipCall |= log_msg(my_device_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t) pInfo->mem, __LINE__, MEMTRACK_MEMORY_LEAK, "MEM", "Mem Object %" PRIu64 " has not been freed. You should clean up this memory by calling " "vkFreeMemory(%" PRIu64 ") prior to vkDestroyDevice().", (uint64_t)(pInfo->mem), (uint64_t)(pInfo->mem)); } } } // Queues persist until device is destroyed delete_queue_info_list(my_device_data); layer_debug_report_destroy_device(device); loader_platform_thread_unlock_mutex(&globalLock); #if DISPATCH_MAP_DEBUG fprintf(stderr, "Device: %p, key: %p\n", device, key); #endif VkLayerDispatchTable *pDisp = my_device_data->device_dispatch_table; if (VK_FALSE == skipCall) { pDisp->DestroyDevice(device, pAllocator); } delete my_device_data->device_dispatch_table; layer_data_map.erase(key); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); VkLayerInstanceDispatchTable *pInstanceTable = my_data->instance_dispatch_table; pInstanceTable->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); memcpy(&memProps, pMemoryProperties, sizeof(VkPhysicalDeviceMemoryProperties)); } static const VkExtensionProperties instance_extensions[] = { { VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION } }; VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) { return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties); } static const VkLayerProperties mtGlobalLayers[] = { { "VK_LAYER_LUNARG_mem_tracker", VK_API_VERSION, VK_MAKE_VERSION(0, 1, 0), "Validation layer: mem_tracker", } }; VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( uint32_t *pCount, VkLayerProperties *pProperties) { return util_GetLayerProperties(ARRAY_SIZE(mtGlobalLayers), mtGlobalLayers, pCount, pProperties); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pCount, VkExtensionProperties *pProperties) { /* Mem tracker does not have any physical device extensions */ if (pLayerName == NULL) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); VkLayerInstanceDispatchTable *pInstanceTable = my_data->instance_dispatch_table; return pInstanceTable->EnumerateDeviceExtensionProperties( physicalDevice, NULL, pCount, pProperties); } else { return util_GetExtensionProperties(0, NULL, pCount, pProperties); } } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) { /* Mem tracker's physical device layers are the same as global */ return util_GetLayerProperties(ARRAY_SIZE(mtGlobalLayers), mtGlobalLayers, pCount, pProperties); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue *pQueue) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); my_data->device_dispatch_table->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); loader_platform_thread_lock_mutex(&globalLock); add_queue_info(my_data, *pQueue); loader_platform_thread_unlock_mutex(&globalLock); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) { layer_data *my_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); // TODO : Need to track fence and clear mem references when fence clears MT_CB_INFO* pCBInfo = NULL; uint64_t fenceId = 0; VkBool32 skipCall = add_fence_info(my_data, fence, queue, &fenceId); print_mem_list(my_data, queue); printCBList(my_data, queue); 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++) { pCBInfo = get_cmd_buf_info(my_data, submit->pCommandBuffers[i]); if (pCBInfo) { pCBInfo->fenceId = fenceId; pCBInfo->lastSubmittedFence = fence; pCBInfo->lastSubmittedQueue = queue; for (auto& function : pCBInfo->validate_functions) { skipCall |= function(); } } } for (uint32_t i = 0; i < submit->waitSemaphoreCount; i++) { VkSemaphore sem = submit->pWaitSemaphores[i]; if (my_data->semaphoreMap.find(sem) != my_data->semaphoreMap.end()) { if (my_data->semaphoreMap[sem] != MEMTRACK_SEMAPHORE_STATE_SIGNALLED) { skipCall = log_msg(my_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"); } my_data->semaphoreMap[sem] = MEMTRACK_SEMAPHORE_STATE_WAIT; } } for (uint32_t i = 0; i < submit->signalSemaphoreCount; i++) { VkSemaphore sem = submit->pSignalSemaphores[i]; if (my_data->semaphoreMap.find(sem) != my_data->semaphoreMap.end()) { if (my_data->semaphoreMap[sem] != MEMTRACK_SEMAPHORE_STATE_UNSET) { skipCall = log_msg(my_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"); } my_data->semaphoreMap[sem] = MEMTRACK_SEMAPHORE_STATE_SIGNALLED; } } } loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { result = my_data->device_dispatch_table->QueueSubmit( queue, submitCount, pSubmits, fence); } 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 (my_data->semaphoreMap.find(sem) != my_data->semaphoreMap.end()) { my_data->semaphoreMap[sem] = MEMTRACK_SEMAPHORE_STATE_UNSET; } } } loader_platform_thread_unlock_mutex(&globalLock); return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); // TODO : Track allocations and overall size here loader_platform_thread_lock_mutex(&globalLock); add_mem_obj_info(my_data, device, *pMemory, pAllocateInfo); print_mem_list(my_data, device); loader_platform_thread_unlock_mutex(&globalLock); return result; } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeMemory( VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks *pAllocator) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); my_data->bufferRanges.erase(mem); my_data->imageRanges.erase(mem); // From spec : A memory object is freed by calling vkFreeMemory() when it is no longer needed. // Before freeing a memory object, an application must ensure the memory object is no longer // in use by the device—for example by command buffers queued for execution. The memory need // not yet be unbound from all images and buffers, but any further use of those images or // buffers (on host or device) for anything other than destroying those objects will result in // undefined behavior. loader_platform_thread_lock_mutex(&globalLock); freeMemObjInfo(my_data, device, mem, VK_FALSE); print_mem_list(my_data, device); printCBList(my_data, device); loader_platform_thread_unlock_mutex(&globalLock); my_data->device_dispatch_table->FreeMemory(device, mem, pAllocator); } VkBool32 validateMemRange( layer_data *my_data, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) { VkBool32 skipCall = VK_FALSE; if (size == 0) { // TODO: a size of 0 is not listed as an invalid use in the spec, should it be? skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, "MEM", "VkMapMemory: Attempting to map memory range of size zero"); } auto mem_element = my_data->memObjMap.find(mem); if (mem_element != my_data->memObjMap.end()) { // It is an application error to call VkMapMemory on an object that is already mapped if (mem_element->second.memRange.size != 0) { skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, "MEM", "VkMapMemory: Attempting to map memory on an already-mapped object %#" PRIxLEAST64, (uint64_t)mem); } // Validate that offset + size is within object's allocationSize if (size == VK_WHOLE_SIZE) { if (offset >= mem_element->second.allocInfo.allocationSize) { skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, "MEM", "Mapping Memory from %" PRIu64 " to %" PRIu64 " with total array size %" PRIu64, offset, mem_element->second.allocInfo.allocationSize, mem_element->second.allocInfo.allocationSize); } } else { if ((offset + size) > mem_element->second.allocInfo.allocationSize) { skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, "MEM", "Mapping Memory from %" PRIu64 " to %" PRIu64 " with total array size %" PRIu64, offset, size + offset, mem_element->second.allocInfo.allocationSize); } } } return skipCall; } void storeMemRanges( layer_data *my_data, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) { auto mem_element = my_data->memObjMap.find(mem); if (mem_element != my_data->memObjMap.end()) { MemRange new_range; new_range.offset = offset; new_range.size = size; mem_element->second.memRange = new_range; } } VkBool32 deleteMemRanges( layer_data *my_data, VkDeviceMemory mem) { VkBool32 skipCall = VK_FALSE; auto mem_element = my_data->memObjMap.find(mem); if (mem_element != my_data->memObjMap.end()) { if (!mem_element->second.memRange.size) { // Valid Usage: memory must currently be mapped skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, "MEM", "Unmapping Memory without memory being mapped: mem obj %#" PRIxLEAST64, (uint64_t)mem); } mem_element->second.memRange.size = 0; if (mem_element->second.pData) { free(mem_element->second.pData); mem_element->second.pData = 0; } } return skipCall; } static char NoncoherentMemoryFillValue = 0xb; void initializeAndTrackMemory( layer_data *my_data, VkDeviceMemory mem, VkDeviceSize size, void **ppData) { auto mem_element = my_data->memObjMap.find(mem); if (mem_element != my_data->memObjMap.end()) { mem_element->second.pDriverData = *ppData; uint32_t index = mem_element->second.allocInfo.memoryTypeIndex; if (memProps.memoryTypes[index].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) { mem_element->second.pData = 0; } else { if (size == VK_WHOLE_SIZE) { size = mem_element->second.allocInfo.allocationSize; } size_t convSize = (size_t)(size); mem_element->second.pData = malloc(2 * convSize); memset(mem_element->second.pData, NoncoherentMemoryFillValue, 2 * convSize); *ppData = static_cast(mem_element->second.pData) + (convSize / 2); } } } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void **ppData) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkBool32 skipCall = VK_FALSE; VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; loader_platform_thread_lock_mutex(&globalLock); MT_MEM_OBJ_INFO *pMemObj = get_mem_obj_info(my_data, mem); if (pMemObj) { pMemObj->valid = true; if ((memProps.memoryTypes[pMemObj->allocInfo.memoryTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0) { skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t) mem, __LINE__, MEMTRACK_INVALID_STATE, "MEM", "Mapping Memory without VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT set: mem obj %#" PRIxLEAST64, (uint64_t) mem); } } skipCall |= validateMemRange(my_data, mem, offset, size); storeMemRanges(my_data, mem, offset, size); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { result = my_data->device_dispatch_table->MapMemory(device, mem, offset, size, flags, ppData); initializeAndTrackMemory(my_data, mem, size, ppData); } return result; } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( VkDevice device, VkDeviceMemory mem) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkBool32 skipCall = VK_FALSE; loader_platform_thread_lock_mutex(&globalLock); skipCall |= deleteMemRanges(my_data, mem); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->UnmapMemory(device, mem); } } VkBool32 validateMemoryIsMapped( layer_data *my_data, uint32_t memRangeCount, const VkMappedMemoryRange *pMemRanges) { VkBool32 skipCall = VK_FALSE; for (uint32_t i = 0; i < memRangeCount; ++i) { auto mem_element = my_data->memObjMap.find(pMemRanges[i].memory); if (mem_element != my_data->memObjMap.end()) { if (mem_element->second.memRange.offset > pMemRanges[i].offset || (mem_element->second.memRange.offset + mem_element->second.memRange.size) < (pMemRanges[i].offset + pMemRanges[i].size)) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)pMemRanges[i].memory, __LINE__, MEMTRACK_INVALID_MAP, "MEM", "Memory must be mapped before it can be flushed or invalidated."); } } } return skipCall; } VkBool32 validateAndCopyNoncoherentMemoryToDriver( layer_data *my_data, uint32_t memRangeCount, const VkMappedMemoryRange *pMemRanges) { VkBool32 skipCall = VK_FALSE; for (uint32_t i = 0; i < memRangeCount; ++i) { auto mem_element = my_data->memObjMap.find(pMemRanges[i].memory); if (mem_element != my_data->memObjMap.end()) { if (mem_element->second.pData) { VkDeviceSize size = mem_element->second.memRange.size; VkDeviceSize half_size = (size / 2); char* data = static_cast(mem_element->second.pData); for (auto j = 0; j < half_size; ++j) { if (data[j] != NoncoherentMemoryFillValue) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)pMemRanges[i].memory, __LINE__, MEMTRACK_INVALID_MAP, "MEM", "Memory overflow was detected on mem obj %" PRIxLEAST64, (uint64_t)pMemRanges[i].memory); } } for (auto j = size + half_size; j < 2 * size; ++j) { if (data[j] != NoncoherentMemoryFillValue) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)pMemRanges[i].memory, __LINE__, MEMTRACK_INVALID_MAP, "MEM", "Memory overflow was detected on mem obj %" PRIxLEAST64, (uint64_t)pMemRanges[i].memory); } } memcpy(mem_element->second.pDriverData, static_cast(data + (size_t)(half_size)), (size_t)(size)); } } } return skipCall; } VK_LAYER_EXPORT VkResult VKAPI_CALL vkFlushMappedMemoryRanges( VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange *pMemRanges) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; VkBool32 skipCall = VK_FALSE; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); loader_platform_thread_lock_mutex(&globalLock); skipCall |= validateAndCopyNoncoherentMemoryToDriver(my_data, memRangeCount, pMemRanges); skipCall |= validateMemoryIsMapped(my_data, memRangeCount, pMemRanges); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall ) { result = my_data->device_dispatch_table->FlushMappedMemoryRanges(device, memRangeCount, pMemRanges); } return result; } VK_LAYER_EXPORT VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange *pMemRanges) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; VkBool32 skipCall = VK_FALSE; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); loader_platform_thread_lock_mutex(&globalLock); skipCall |= validateMemoryIsMapped(my_data, memRangeCount, pMemRanges); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { result = my_data->device_dispatch_table->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges); } return result; } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); loader_platform_thread_lock_mutex(&globalLock); delete_fence_info(my_data, fence); auto item = my_data->fenceMap.find(fence); if (item != my_data->fenceMap.end()) { my_data->fenceMap.erase(item); } loader_platform_thread_unlock_mutex(&globalLock); my_data->device_dispatch_table->DestroyFence(device, fence, pAllocator); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkBool32 skipCall = VK_FALSE; loader_platform_thread_lock_mutex(&globalLock); auto item = my_data->bufferMap.find((uint64_t)buffer); if (item != my_data->bufferMap.end()) { skipCall = clear_object_binding(my_data, device, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT); my_data->bufferMap.erase(item); } loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->DestroyBuffer(device, buffer, pAllocator); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkBool32 skipCall = VK_FALSE; loader_platform_thread_lock_mutex(&globalLock); auto item = my_data->imageMap.find((uint64_t)image); if (item != my_data->imageMap.end()) { skipCall = clear_object_binding(my_data, device, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT); my_data->imageMap.erase(item); } loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->DestroyImage(device, image, pAllocator); } } VkBool32 print_memory_range_error(layer_data *my_data, const uint64_t object_handle, const uint64_t other_handle, VkDebugReportObjectTypeEXT object_type) { if (object_type == VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT) { return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle, 0, MEMTRACK_INVALID_ALIASING, "MEM", "Buffer %" PRIx64 " is alised with image %" PRIx64, object_handle, other_handle); } else { return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle, 0, MEMTRACK_INVALID_ALIASING, "MEM", "Image %" PRIx64 " is alised with buffer %" PRIx64, object_handle, other_handle); } } VkBool32 validate_memory_range(layer_data *my_data, const unordered_map>& memory, const MEMORY_RANGE& new_range, VkDebugReportObjectTypeEXT object_type) { VkBool32 skip_call = false; if (!memory.count(new_range.memory)) return false; const vector& ranges = memory.at(new_range.memory); for (auto range : ranges) { if ((range.end & ~(my_data->properties.limits.bufferImageGranularity - 1)) < new_range.start) continue; if (range.start > (new_range.end & ~(my_data->properties.limits.bufferImageGranularity - 1))) continue; skip_call |= print_memory_range_error(my_data, new_range.handle, range.handle, object_type); } return skip_call; } VkBool32 validate_buffer_image_aliasing( layer_data *my_data, uint64_t handle, VkDeviceMemory mem, VkDeviceSize memoryOffset, VkMemoryRequirements memRequirements, unordered_map>& ranges, const unordered_map>& other_ranges, VkDebugReportObjectTypeEXT object_type) { MEMORY_RANGE range; range.handle = handle; range.memory = mem; range.start = memoryOffset; range.end = memoryOffset + memRequirements.size - 1; ranges[mem].push_back(range); return validate_memory_range(my_data, other_ranges, range, object_type); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; loader_platform_thread_lock_mutex(&globalLock); // Track objects tied to memory uint64_t buffer_handle = (uint64_t)(buffer); VkBool32 skipCall = set_mem_binding(my_data, device, mem, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "vkBindBufferMemory"); add_object_binding_info(my_data, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, mem); { VkMemoryRequirements memRequirements; vkGetBufferMemoryRequirements(device, buffer, &memRequirements); skipCall |= validate_buffer_image_aliasing(my_data, buffer_handle, mem, memoryOffset, memRequirements, my_data->bufferRanges, my_data->imageRanges, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT); } print_mem_list(my_data, device); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { result = my_data->device_dispatch_table->BindBufferMemory(device, buffer, mem, memoryOffset); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; loader_platform_thread_lock_mutex(&globalLock); // Track objects tied to memory uint64_t image_handle = (uint64_t)(image); VkBool32 skipCall = set_mem_binding(my_data, device, mem, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkBindImageMemory"); add_object_binding_info(my_data, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, mem); { VkMemoryRequirements memRequirements; vkGetImageMemoryRequirements(device, image, &memRequirements); skipCall |= validate_buffer_image_aliasing(my_data, image_handle, mem, memoryOffset, memRequirements, my_data->imageRanges, my_data->bufferRanges, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT); } print_mem_list(my_data, device); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { result = my_data->device_dispatch_table->BindImageMemory(device, image, mem, memoryOffset); } return result; } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); // TODO : What to track here? // Could potentially save returned mem requirements and validate values passed into BindBufferMemory my_data->device_dispatch_table->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); // TODO : What to track here? // Could potentially save returned mem requirements and validate values passed into BindImageMemory my_data->device_dispatch_table->GetImageMemoryRequirements(device, image, pMemoryRequirements); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; VkBool32 skipCall = VK_FALSE; loader_platform_thread_lock_mutex(&globalLock); for (uint32_t i = 0; i < bindInfoCount; i++) { // Track objects tied to memory for (uint32_t j = 0; j < pBindInfo[i].bufferBindCount; j++) { for (uint32_t k = 0; k < pBindInfo[i].pBufferBinds[j].bindCount; k++) { if (set_sparse_mem_binding(my_data, queue, pBindInfo[i].pBufferBinds[j].pBinds[k].memory, (uint64_t) pBindInfo[i].pBufferBinds[j].buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "vkQueueBindSparse")) skipCall = VK_TRUE; } } for (uint32_t j = 0; j < pBindInfo[i].imageOpaqueBindCount; j++) { for (uint32_t k = 0; k < pBindInfo[i].pImageOpaqueBinds[j].bindCount; k++) { if (set_sparse_mem_binding(my_data, queue, pBindInfo[i].pImageOpaqueBinds[j].pBinds[k].memory, (uint64_t) pBindInfo[i].pImageOpaqueBinds[j].image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkQueueBindSparse")) skipCall = VK_TRUE; } } for (uint32_t j = 0; j < pBindInfo[i].imageBindCount; j++) { for (uint32_t k = 0; k < pBindInfo[i].pImageBinds[j].bindCount; k++) { if (set_sparse_mem_binding(my_data, queue, pBindInfo[i].pImageBinds[j].pBinds[k].memory, (uint64_t) pBindInfo[i].pImageBinds[j].image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkQueueBindSparse")) skipCall = VK_TRUE; } } } print_mem_list(my_data, queue); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { result = my_data->device_dispatch_table->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->CreateFence(device, pCreateInfo, pAllocator, pFence); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); MT_FENCE_INFO* pFI = &my_data->fenceMap[*pFence]; memset(pFI, 0, sizeof(MT_FENCE_INFO)); memcpy(&(pFI->createInfo), pCreateInfo, sizeof(VkFenceCreateInfo)); if (pCreateInfo->flags & VK_FENCE_CREATE_SIGNALED_BIT) { pFI->firstTimeFlag = VK_TRUE; } loader_platform_thread_unlock_mutex(&globalLock); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence *pFences) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; VkBool32 skipCall = VK_FALSE; loader_platform_thread_lock_mutex(&globalLock); // Reset fence state in fenceCreateInfo structure for (uint32_t i = 0; i < fenceCount; i++) { auto fence_item = my_data->fenceMap.find(pFences[i]); if (fence_item != my_data->fenceMap.end()) { // Validate fences in SIGNALED state if (!(fence_item->second.createInfo.flags & VK_FENCE_CREATE_SIGNALED_BIT)) { // TODO: I don't see a Valid Usage section for ResetFences. This behavior should be documented there. skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, (uint64_t) pFences[i], __LINE__, MEMTRACK_INVALID_FENCE_STATE, "MEM", "Fence %#" PRIxLEAST64 " submitted to VkResetFences in UNSIGNALED STATE", (uint64_t) pFences[i]); } else { fence_item->second.createInfo.flags = static_cast(fence_item->second.createInfo.flags & ~VK_FENCE_CREATE_SIGNALED_BIT); } } } loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { result = my_data->device_dispatch_table->ResetFences(device, fenceCount, pFences); } return result; } static inline VkBool32 verifyFenceStatus( VkDevice device, VkFence fence, const char *apiCall) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkBool32 skipCall = VK_FALSE; auto pFenceInfo = my_data->fenceMap.find(fence); if (pFenceInfo != my_data->fenceMap.end()) { if (pFenceInfo->second.firstTimeFlag != VK_TRUE) { if ((pFenceInfo->second.createInfo.flags & VK_FENCE_CREATE_SIGNALED_BIT) && pFenceInfo->second.firstTimeFlag != VK_TRUE) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, (uint64_t) fence, __LINE__, MEMTRACK_INVALID_FENCE_STATE, "MEM", "%s specified fence %#" PRIxLEAST64 " already in SIGNALED state.", apiCall, (uint64_t) fence); } if (!pFenceInfo->second.queue && !pFenceInfo->second .swapchain) { // Checking status of unsubmitted fence skipCall |= log_msg( my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, reinterpret_cast(fence), __LINE__, MEMTRACK_INVALID_FENCE_STATE, "MEM", "%s called for fence %#" PRIxLEAST64 " which has not been submitted on a Queue or during " "acquire next image.", apiCall, reinterpret_cast(fence)); } } else { pFenceInfo->second.firstTimeFlag = VK_FALSE; } } return skipCall; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( VkDevice device, VkFence fence) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); loader_platform_thread_lock_mutex(&globalLock); VkBool32 skipCall = verifyFenceStatus(device, fence, "vkGetFenceStatus"); loader_platform_thread_unlock_mutex(&globalLock); if (skipCall) return VK_ERROR_VALIDATION_FAILED_EXT; VkResult result = my_data->device_dispatch_table->GetFenceStatus(device, fence); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); update_fence_tracking(my_data, fence); loader_platform_thread_unlock_mutex(&globalLock); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkBool32 skipCall = VK_FALSE; // Verify fence status of submitted fences loader_platform_thread_lock_mutex(&globalLock); for(uint32_t i = 0; i < fenceCount; i++) { skipCall |= verifyFenceStatus(device, pFences[i], "vkWaitForFences"); } loader_platform_thread_unlock_mutex(&globalLock); if (skipCall) return VK_ERROR_VALIDATION_FAILED_EXT; VkResult result = my_data->device_dispatch_table->WaitForFences(device, fenceCount, pFences, waitAll, timeout); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); if (waitAll || fenceCount == 1) { // Clear all the fences for(uint32_t i = 0; i < fenceCount; i++) { update_fence_tracking(my_data, pFences[i]); } } loader_platform_thread_unlock_mutex(&globalLock); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( VkQueue queue) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map); VkResult result = my_data->device_dispatch_table->QueueWaitIdle(queue); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); retire_queue_fences(my_data, queue); loader_platform_thread_unlock_mutex(&globalLock); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( VkDevice device) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->DeviceWaitIdle(device); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); retire_device_fences(my_data, device); loader_platform_thread_unlock_mutex(&globalLock); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); add_object_create_info(my_data, (uint64_t)*pBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, pCreateInfo); loader_platform_thread_unlock_mutex(&globalLock); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); add_object_create_info(my_data, (uint64_t)*pImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, pCreateInfo); loader_platform_thread_unlock_mutex(&globalLock); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); my_data->imageViewMap[*pView].image = pCreateInfo->image; // Validate that img has correct usage flags set validate_image_usage_flags(my_data, device, pCreateInfo->image, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_FALSE, "vkCreateImageView()", "VK_IMAGE_USAGE_[SAMPLED|STORAGE|COLOR_ATTACHMENT]_BIT"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pAllocator, pView); if (result == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); // In order to create a valid buffer view, the buffer must have been created with at least one of the // following flags: UNIFORM_TEXEL_BUFFER_BIT or STORAGE_TEXEL_BUFFER_BIT validate_buffer_usage_flags(my_data, device, pCreateInfo->buffer, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, VK_FALSE, "vkCreateBufferView()", "VK_BUFFER_USAGE_[STORAGE|UNIFORM]_TEXEL_BUFFER_BIT"); loader_platform_thread_unlock_mutex(&globalLock); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo *pCreateInfo, VkCommandBuffer *pCommandBuffer) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer); loader_platform_thread_lock_mutex(&globalLock); if (VK_SUCCESS == result) { for (uint32_t i = 0; i < pCreateInfo->commandBufferCount; i++) { add_cmd_buf_info(my_data, pCreateInfo->commandPool, pCommandBuffer[i]); } } loader_platform_thread_unlock_mutex(&globalLock); printCBList(my_data, device); return result; } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) { VkBool32 skipCall = VK_FALSE; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); loader_platform_thread_lock_mutex(&globalLock); for (uint32_t i = 0; i < commandBufferCount; i++) { skipCall |= delete_cmd_buf_info(my_data, commandPool, pCommandBuffers[i]); } printCBList(my_data, device); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); } } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); loader_platform_thread_lock_mutex(&globalLock); // Add cmd pool to map my_data->commandPoolMap[*pCommandPool].createFlags = pCreateInfo->flags; loader_platform_thread_unlock_mutex(&globalLock); return result; } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) { VkBool32 commandBufferComplete = VK_FALSE; VkBool32 skipCall = VK_FALSE; // Verify that command buffers in pool are complete (not in-flight) layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); loader_platform_thread_lock_mutex(&globalLock); for (auto it = my_data->commandPoolMap[commandPool].pCommandBuffers.begin(); it != my_data->commandPoolMap[commandPool].pCommandBuffers.end(); it++) { commandBufferComplete = VK_FALSE; skipCall = checkCBCompleted(my_data, *it, &commandBufferComplete); if (VK_FALSE == commandBufferComplete) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)(*it), __LINE__, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Destroying Command Pool 0x%" PRIxLEAST64 " before " "its command buffer (0x%" PRIxLEAST64 ") has completed.", (uint64_t)(commandPool), reinterpret_cast(*it)); } } loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->DestroyCommandPool(device, commandPool, pAllocator); } loader_platform_thread_lock_mutex(&globalLock); auto item = my_data->commandPoolMap[commandPool].pCommandBuffers.begin(); // Remove command buffers from command buffer map while (item != my_data->commandPoolMap[commandPool].pCommandBuffers.end()) { auto del_item = item++; delete_cmd_buf_info(my_data, commandPool, *del_item); } my_data->commandPoolMap.erase(commandPool); loader_platform_thread_unlock_mutex(&globalLock); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkBool32 commandBufferComplete = VK_FALSE; VkBool32 skipCall = VK_FALSE; VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; loader_platform_thread_lock_mutex(&globalLock); auto it = my_data->commandPoolMap[commandPool].pCommandBuffers.begin(); // Verify that CB's in pool are complete (not in-flight) while (it != my_data->commandPoolMap[commandPool].pCommandBuffers.end()) { skipCall = checkCBCompleted(my_data, (*it), &commandBufferComplete); if (VK_FALSE == commandBufferComplete) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)(*it), __LINE__, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Resetting CB %p before it has completed. You must check CB " "flag before calling vkResetCommandBuffer().", (*it)); } else { // Clear memory references at this point. skipCall |= clear_cmd_buf_and_mem_references(my_data, (*it)); } ++it; } loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { result = my_data->device_dispatch_table->ResetCommandPool(device, commandPool, flags); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; VkBool32 skipCall = VK_FALSE; VkBool32 commandBufferComplete = VK_FALSE; loader_platform_thread_lock_mutex(&globalLock); // This implicitly resets the Cmd Buffer so make sure any fence is done and then clear memory references skipCall = checkCBCompleted(my_data, commandBuffer, &commandBufferComplete); if (VK_FALSE == commandBufferComplete) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)commandBuffer, __LINE__, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Calling vkBeginCommandBuffer() on active CB %p before it has completed. " "You must check CB flag before this call.", commandBuffer); } loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { result = my_data->device_dispatch_table->BeginCommandBuffer(commandBuffer, pBeginInfo); } loader_platform_thread_lock_mutex(&globalLock); clear_cmd_buf_and_mem_references(my_data, commandBuffer); loader_platform_thread_unlock_mutex(&globalLock); return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( VkCommandBuffer commandBuffer) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); // TODO : Anything to do here? VkResult result = my_data->device_dispatch_table->EndCommandBuffer(commandBuffer); return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; VkBool32 skipCall = VK_FALSE; VkBool32 commandBufferComplete = VK_FALSE; loader_platform_thread_lock_mutex(&globalLock); // Verify that CB is complete (not in-flight) skipCall = checkCBCompleted(my_data, commandBuffer, &commandBufferComplete); if (VK_FALSE == commandBufferComplete) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)commandBuffer, __LINE__, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Resetting CB %p before it has completed. You must check CB " "flag before calling vkResetCommandBuffer().", commandBuffer); } // Clear memory references as this point. skipCall |= clear_cmd_buf_and_mem_references(my_data, commandBuffer); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { result = my_data->device_dispatch_table->ResetCommandBuffer(commandBuffer, flags); } return result; } // TODO : For any vkCmdBind* calls that include an object which has mem bound to it, // need to account for that mem now having binding to given commandBuffer VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); #if 0 // FIXME: NEED TO FIX THE FOLLOWING CODE AND REMOVE THIS #if 0 // TODO : If memory bound to pipeline, then need to tie that mem to commandBuffer if (getPipeline(pipeline)) { MT_CB_INFO *pCBInfo = get_cmd_buf_info(my_data, commandBuffer); if (pCBInfo) { pCBInfo->pipelines[pipelineBindPoint] = pipeline; } } else { "Attempt to bind Pipeline %p that doesn't exist!", (void*)pipeline); layerCbMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, pipeline, __LINE__, MEMTRACK_INVALID_OBJECT, (char *) "DS", (char *) str); } #endif my_data->device_dispatch_table->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); auto cb_data = my_data->cbMap.find(commandBuffer); if (cb_data != my_data->cbMap.end()) { std::vector& activeDescriptorSets = cb_data->second.activeDescriptorSets; if (activeDescriptorSets.size() < (setCount + firstSet)) { activeDescriptorSets.resize(setCount + firstSet); } for (uint32_t i = 0; i < setCount; ++i) { activeDescriptorSets[i + firstSet] = pDescriptorSets[i]; } } // TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state my_data->device_dispatch_table->CmdBindDescriptorSets( commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkBool32 skip_call = false; loader_platform_thread_lock_mutex(&globalLock); for (uint32_t i = 0; i < bindingCount; ++i) { VkDeviceMemory mem; skip_call |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)(pBuffers[i]), VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); auto cb_data = my_data->cbMap.find(commandBuffer); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { return validate_memory_is_valid(my_data, mem, "vkCmdBindVertexBuffers()"); }; cb_data->second.validate_functions.push_back(function); } } loader_platform_thread_unlock_mutex(&globalLock); // TODO : Somewhere need to verify that VBs have correct usage state flagged if (!skip_call) my_data->device_dispatch_table->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; loader_platform_thread_lock_mutex(&globalLock); VkBool32 skip_call = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)(buffer), VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); auto cb_data = my_data->cbMap.find(commandBuffer); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { return validate_memory_is_valid(my_data, mem, "vkCmdBindIndexBuffer()"); }; cb_data->second.validate_functions.push_back(function); } loader_platform_thread_unlock_mutex(&globalLock); // TODO : Somewhere need to verify that IBs have correct usage state flagged if (!skip_call) my_data->device_dispatch_table->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); for (uint32_t i = 0; i < descriptorWriteCount; ++i) { if (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) { my_data->descriptorSetMap[pDescriptorWrites[i].dstSet].images.push_back(pDescriptorWrites[i].pImageInfo->imageView); } else if (pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER || pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || pDescriptorWrites[i].descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC) { my_data->descriptorSetMap[pDescriptorWrites[i].dstSet].buffers.push_back(pDescriptorWrites[i].pBufferInfo->buffer); } } my_data->device_dispatch_table->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); } bool markStoreImagesAndBuffersAsWritten( VkCommandBuffer commandBuffer) { bool skip_call = false; loader_platform_thread_lock_mutex(&globalLock); layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); auto cb_data = my_data->cbMap.find(commandBuffer); if (cb_data == my_data->cbMap.end()) return skip_call; std::vector& activeDescriptorSets = cb_data->second.activeDescriptorSets; for (auto descriptorSet : activeDescriptorSets) { auto ds_data = my_data->descriptorSetMap.find(descriptorSet); if (ds_data == my_data->descriptorSetMap.end()) continue; std::vector images = ds_data->second.images; std::vector buffers = ds_data->second.buffers; for (auto imageView : images) { auto iv_data = my_data->imageViewMap.find(imageView); if (iv_data == my_data->imageViewMap.end()) continue; VkImage image = iv_data->second.image; VkDeviceMemory mem; skip_call |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); std::function function = [=]() { set_memory_valid(my_data, mem, true, image); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } for (auto buffer : buffers) { VkDeviceMemory mem; skip_call |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); std::function function = [=]() { set_memory_valid(my_data, mem, true); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } } loader_platform_thread_unlock_mutex(&globalLock); return skip_call; } VKAPI_ATTR void VKAPI_CALL vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); bool skip_call = markStoreImagesAndBuffersAsWritten(commandBuffer); if (!skip_call) my_data->device_dispatch_table->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); } VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); bool skip_call = markStoreImagesAndBuffersAsWritten(commandBuffer); if (!skip_call) my_data->device_dispatch_table->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; loader_platform_thread_lock_mutex(&globalLock); VkBool32 skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdDrawIndirect"); skipCall |= markStoreImagesAndBuffersAsWritten(commandBuffer); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdDrawIndirect(commandBuffer, buffer, offset, count, stride); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; loader_platform_thread_lock_mutex(&globalLock); VkBool32 skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdDrawIndexedIndirect"); skipCall |= markStoreImagesAndBuffersAsWritten(commandBuffer); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride); } } VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); bool skip_call = markStoreImagesAndBuffersAsWritten(commandBuffer); if (!skip_call) my_data->device_dispatch_table->CmdDispatch(commandBuffer, x, y, z); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; loader_platform_thread_lock_mutex(&globalLock); VkBool32 skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdDispatchIndirect"); skipCall |= markStoreImagesAndBuffersAsWritten(commandBuffer); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdDispatchIndirect(commandBuffer, buffer, offset); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; VkBool32 skipCall = VK_FALSE; auto cb_data = my_data->cbMap.find(commandBuffer); loader_platform_thread_lock_mutex(&globalLock); skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { return validate_memory_is_valid(my_data, mem, "vkCmdCopyBuffer()"); }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyBuffer"); skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, mem, true); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyBuffer"); // Validate that SRC & DST buffers have correct usage flags set skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"); skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize destStride, VkQueryResultFlags flags) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; VkBool32 skipCall = VK_FALSE; auto cb_data = my_data->cbMap.find(commandBuffer); loader_platform_thread_lock_mutex(&globalLock); skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, mem, true); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyQueryPoolResults"); // Validate that DST buffer has correct usage flags set skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyQueryPoolResults()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, destStride, flags); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; VkBool32 skipCall = VK_FALSE; auto cb_data = my_data->cbMap.find(commandBuffer); loader_platform_thread_lock_mutex(&globalLock); // Validate that src & dst images have correct usage flags set skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { return validate_memory_is_valid(my_data, mem, "vkCmdCopyImage()", srcImage); }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyImage"); skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, mem, true, dstImage); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyImage"); skipCall |= validate_image_usage_flags(my_data, commandBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"); skipCall |= validate_image_usage_flags(my_data, commandBuffer, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT"); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; VkBool32 skipCall = VK_FALSE; auto cb_data = my_data->cbMap.find(commandBuffer); loader_platform_thread_lock_mutex(&globalLock); // Validate that src & dst images have correct usage flags set skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { return validate_memory_is_valid(my_data, mem, "vkCmdBlitImage()", srcImage); }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdBlitImage"); skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem);\ if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, mem, true, dstImage); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdBlitImage"); skipCall |= validate_image_usage_flags(my_data, commandBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"); skipCall |= validate_image_usage_flags(my_data, commandBuffer, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT"); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; VkBool32 skipCall = VK_FALSE; auto cb_data = my_data->cbMap.find(commandBuffer); loader_platform_thread_lock_mutex(&globalLock); skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, mem, true, dstImage); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyBufferToImage"); skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { return validate_memory_is_valid(my_data, mem, "vkCmdCopyBufferToImage()"); }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyBufferToImage"); // Validate that src buff & dst image have correct usage flags set skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyBufferToImage()", "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"); skipCall |= validate_image_usage_flags(my_data, commandBuffer, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyBufferToImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT"); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; VkBool32 skipCall = VK_FALSE; auto cb_data = my_data->cbMap.find(commandBuffer); loader_platform_thread_lock_mutex(&globalLock); skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { return validate_memory_is_valid(my_data, mem, "vkCmdCopyImageToBuffer()", srcImage); }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyImageToBuffer"); skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, mem, true); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdCopyImageToBuffer"); // Validate that dst buff & src image have correct usage flags set skipCall |= validate_image_usage_flags(my_data, commandBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyImageToBuffer()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"); skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyImageToBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t *pData) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; VkBool32 skipCall = VK_FALSE; auto cb_data = my_data->cbMap.find(commandBuffer); loader_platform_thread_lock_mutex(&globalLock); skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, mem, true); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdUpdateBuffer"); // Validate that dst buff has correct usage flags set skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdUpdateBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; VkBool32 skipCall = VK_FALSE; auto cb_data = my_data->cbMap.find(commandBuffer); loader_platform_thread_lock_mutex(&globalLock); skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, mem, true); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdFillBuffer"); // Validate that dst buff has correct usage flags set skipCall |= validate_buffer_usage_flags(my_data, commandBuffer, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdFillBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state VkDeviceMemory mem; VkBool32 skipCall = VK_FALSE; auto cb_data = my_data->cbMap.find(commandBuffer); loader_platform_thread_lock_mutex(&globalLock); skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, mem, true, image); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdClearColorImage"); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state VkDeviceMemory mem; VkBool32 skipCall = VK_FALSE; auto cb_data = my_data->cbMap.find(commandBuffer); loader_platform_thread_lock_mutex(&globalLock); skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, mem, true, image); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdClearDepthStencilImage"); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkBool32 skipCall = VK_FALSE; auto cb_data = my_data->cbMap.find(commandBuffer); loader_platform_thread_lock_mutex(&globalLock); VkDeviceMemory mem; skipCall = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { return validate_memory_is_valid(my_data, mem, "vkCmdResolveImage()", srcImage); }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdResolveImage"); skipCall |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, mem, true, dstImage); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } skipCall |= update_cmd_buf_and_mem_references(my_data, commandBuffer, mem, "vkCmdResolveImage"); loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->CmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); my_data->device_dispatch_table->CmdBeginQuery(commandBuffer, queryPool, slot, flags); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); my_data->device_dispatch_table->CmdEndQuery(commandBuffer, queryPool, slot); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); my_data->device_dispatch_table->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pMsgCallback) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table; VkResult res = pTable->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback); if (res == VK_SUCCESS) { loader_platform_thread_lock_mutex(&globalLock); res = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback); loader_platform_thread_unlock_mutex(&globalLock); } return res; } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( VkInstance instance, VkDebugReportCallbackEXT msgCallback, const VkAllocationCallbacks* pAllocator) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table; pTable->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); loader_platform_thread_lock_mutex(&globalLock); layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator); loader_platform_thread_unlock_mutex(&globalLock); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location, int32_t msgCode, const char* pLayerPrefix, const char* pMsg) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); my_data->instance_dispatch_table->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); if (VK_SUCCESS == result) { loader_platform_thread_lock_mutex(&globalLock); add_swap_chain_info(my_data, *pSwapchain, pCreateInfo); loader_platform_thread_unlock_mutex(&globalLock); } return result; } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkBool32 skipCall = VK_FALSE; loader_platform_thread_lock_mutex(&globalLock); if (my_data->swapchainMap.find(swapchain) != my_data->swapchainMap.end()) { MT_SWAP_CHAIN_INFO* pInfo = my_data->swapchainMap[swapchain]; if (pInfo->images.size() > 0) { for (auto it = pInfo->images.begin(); it != pInfo->images.end(); it++) { skipCall = clear_object_binding(my_data, device, (uint64_t)*it, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT); auto image_item = my_data->imageMap.find((uint64_t)*it); if (image_item != my_data->imageMap.end()) my_data->imageMap.erase(image_item); } } delete pInfo; my_data->swapchainMap.erase(swapchain); } loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { my_data->device_dispatch_table->DestroySwapchainKHR(device, swapchain, pAllocator); } } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t *pCount, VkImage *pSwapchainImages) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages); loader_platform_thread_lock_mutex(&globalLock); if (result == VK_SUCCESS && pSwapchainImages != NULL) { const size_t count = *pCount; MT_SWAP_CHAIN_INFO *pInfo = my_data->swapchainMap[swapchain]; if (pInfo->images.empty()) { pInfo->images.resize(count); memcpy(&pInfo->images[0], pSwapchainImages, sizeof(pInfo->images[0]) * count); if (pInfo->images.size() > 0) { for (std::vector::const_iterator it = pInfo->images.begin(); it != pInfo->images.end(); it++) { // Add image object binding, then insert the new Mem Object and then bind it to created image add_object_create_info(my_data, (uint64_t)*it, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, &pInfo->createInfo); } } } else { const size_t count = *pCount; MT_SWAP_CHAIN_INFO *pInfo = my_data->swapchainMap[swapchain]; const VkBool32 mismatch = (pInfo->images.size() != count || memcmp(&pInfo->images[0], pSwapchainImages, sizeof(pInfo->images[0]) * count)); if (mismatch) { // TODO: Verify against Valid Usage section of extension log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, (uint64_t) swapchain, __LINE__, MEMTRACK_NONE, "SWAP_CHAIN", "vkGetSwapchainInfoKHR(%" PRIu64 ", VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_KHR) returned mismatching data", (uint64_t)(swapchain)); } } } loader_platform_thread_unlock_mutex(&globalLock); return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; VkBool32 skipCall = VK_FALSE; loader_platform_thread_lock_mutex(&globalLock); if (my_data->semaphoreMap.find(semaphore) != my_data->semaphoreMap.end()) { if (my_data->semaphoreMap[semaphore] != MEMTRACK_SEMAPHORE_STATE_UNSET) { skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, (uint64_t)semaphore, __LINE__, MEMTRACK_NONE, "SEMAPHORE", "vkAcquireNextImageKHR: Semaphore must not be currently signaled or in a wait state"); } my_data->semaphoreMap[semaphore] = MEMTRACK_SEMAPHORE_STATE_SIGNALLED; } auto fence_data = my_data->fenceMap.find(fence); if (fence_data != my_data->fenceMap.end()) { fence_data->second.swapchain = swapchain; } loader_platform_thread_unlock_mutex(&globalLock); if (VK_FALSE == skipCall) { result = my_data->device_dispatch_table->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); } return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map); VkBool32 skip_call = false; VkDeviceMemory mem; loader_platform_thread_lock_mutex(&globalLock); for (uint32_t i = 0; i < pPresentInfo->swapchainCount; ++i) { MT_SWAP_CHAIN_INFO *pInfo = my_data->swapchainMap[pPresentInfo->pSwapchains[i]]; VkImage image = pInfo->images[pPresentInfo->pImageIndices[i]]; skip_call |= get_mem_binding_from_object(my_data, queue, (uint64_t)(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem); skip_call |= validate_memory_is_valid(my_data, mem, "vkQueuePresentKHR()", image); } loader_platform_thread_unlock_mutex(&globalLock); if (!skip_call) { result = my_data->device_dispatch_table->QueuePresentKHR(queue, pPresentInfo); } loader_platform_thread_lock_mutex(&globalLock); for (uint32_t i = 0; i < pPresentInfo->waitSemaphoreCount; i++) { VkSemaphore sem = pPresentInfo->pWaitSemaphores[i]; if (my_data->semaphoreMap.find(sem) != my_data->semaphoreMap.end()) { my_data->semaphoreMap[sem] = MEMTRACK_SEMAPHORE_STATE_UNSET; } } loader_platform_thread_unlock_mutex(&globalLock); return result; } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); loader_platform_thread_lock_mutex(&globalLock); if (*pSemaphore != VK_NULL_HANDLE) { my_data->semaphoreMap[*pSemaphore] = MEMTRACK_SEMAPHORE_STATE_UNSET; } loader_platform_thread_unlock_mutex(&globalLock); return result; } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); loader_platform_thread_lock_mutex(&globalLock); auto item = my_data->semaphoreMap.find(semaphore); if (item != my_data->semaphoreMap.end()) { my_data->semaphoreMap.erase(item); } loader_platform_thread_unlock_mutex(&globalLock); my_data->device_dispatch_table->DestroySemaphore(device, semaphore, pAllocator); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); loader_platform_thread_lock_mutex(&globalLock); for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { VkImageView view = pCreateInfo->pAttachments[i]; auto view_data = my_data->imageViewMap.find(view); if (view_data == my_data->imageViewMap.end()) { continue; } MT_FB_ATTACHMENT_INFO fb_info; get_mem_binding_from_object(my_data, device, (uint64_t)(view_data->second.image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &fb_info.mem); fb_info.image = view_data->second.image; my_data->fbMap[*pFramebuffer].attachments.push_back(fb_info); } loader_platform_thread_unlock_mutex(&globalLock); return result; } VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); loader_platform_thread_lock_mutex(&globalLock); auto item = my_data->fbMap.find(framebuffer); if (item != my_data->fbMap.end()) { my_data->fbMap.erase(framebuffer); } loader_platform_thread_unlock_mutex(&globalLock); my_data->device_dispatch_table->DestroyFramebuffer(device, framebuffer, pAllocator); } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = my_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); loader_platform_thread_lock_mutex(&globalLock); for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { VkAttachmentDescription desc = pCreateInfo->pAttachments[i]; MT_PASS_ATTACHMENT_INFO pass_info; pass_info.load_op = desc.loadOp; pass_info.store_op = desc.storeOp; pass_info.attachment = i; my_data->passMap[*pRenderPass].attachments.push_back(pass_info); } //TODO: Maybe fill list and then copy instead of locking std::unordered_map& attachment_first_read = my_data->passMap[*pRenderPass].attachment_first_read; std::unordered_map& attachment_first_layout = my_data->passMap[*pRenderPass].attachment_first_layout; for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) { const VkSubpassDescription& subpass = pCreateInfo->pSubpasses[i]; for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) { uint32_t attachment = subpass.pInputAttachments[j].attachment; if (attachment_first_read.count(attachment)) continue; attachment_first_read.insert(std::make_pair(attachment, true)); attachment_first_layout.insert(std::make_pair(attachment, subpass.pInputAttachments[j].layout)); } for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) { uint32_t attachment = subpass.pColorAttachments[j].attachment; if (attachment_first_read.count(attachment)) continue; attachment_first_read.insert(std::make_pair(attachment, false)); attachment_first_layout.insert(std::make_pair(attachment, subpass.pColorAttachments[j].layout)); } if (subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { uint32_t attachment = subpass.pDepthStencilAttachment->attachment; if (attachment_first_read.count(attachment)) continue; attachment_first_read.insert(std::make_pair(attachment, false)); attachment_first_layout.insert(std::make_pair(attachment, subpass.pDepthStencilAttachment->layout)); } } loader_platform_thread_unlock_mutex(&globalLock); return result; } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); my_data->device_dispatch_table->DestroyRenderPass(device, renderPass, pAllocator); loader_platform_thread_lock_mutex(&globalLock); my_data->passMap.erase(renderPass); loader_platform_thread_unlock_mutex(&globalLock); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map); VkBool32 skip_call = false; if (pRenderPassBegin) { loader_platform_thread_lock_mutex(&globalLock); auto pass_data = my_data->passMap.find(pRenderPassBegin->renderPass); if (pass_data != my_data->passMap.end()) { MT_PASS_INFO& pass_info = pass_data->second; pass_info.fb = pRenderPassBegin->framebuffer; auto cb_data = my_data->cbMap.find(cmdBuffer); for (size_t i = 0; i < pass_info.attachments.size(); ++i) { MT_FB_ATTACHMENT_INFO& fb_info = my_data->fbMap[pass_info.fb].attachments[i]; if (pass_info.attachments[i].load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, fb_info.mem, true, fb_info.image); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } VkImageLayout& attachment_layout = pass_info.attachment_first_layout[pass_info.attachments[i].attachment]; if (attachment_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL || attachment_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) { skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, (uint64_t)(pRenderPassBegin->renderPass), __LINE__, MEMTRACK_INVALID_LAYOUT, "MEM", "Cannot clear attachment %d with invalid first layout %d.", pass_info.attachments[i].attachment, attachment_layout); } } else if (pass_info.attachments[i].load_op == VK_ATTACHMENT_LOAD_OP_DONT_CARE) { if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, fb_info.mem, false, fb_info.image); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } } else if (pass_info.attachments[i].load_op == VK_ATTACHMENT_LOAD_OP_LOAD) { if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { return validate_memory_is_valid(my_data, fb_info.mem, "vkCmdBeginRenderPass()", fb_info.image); }; cb_data->second.validate_functions.push_back(function); } } if (pass_info.attachment_first_read[pass_info.attachments[i].attachment]) { if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { return validate_memory_is_valid(my_data, fb_info.mem, "vkCmdBeginRenderPass()", fb_info.image); }; cb_data->second.validate_functions.push_back(function); } } } if (cb_data != my_data->cbMap.end()) { cb_data->second.pass = pRenderPassBegin->renderPass; } } loader_platform_thread_unlock_mutex(&globalLock); } if (!skip_call) return my_data->device_dispatch_table->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( VkCommandBuffer cmdBuffer) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map); loader_platform_thread_lock_mutex(&globalLock); auto cb_data = my_data->cbMap.find(cmdBuffer); if (cb_data != my_data->cbMap.end()) { auto pass_data = my_data->passMap.find(cb_data->second.pass); if (pass_data != my_data->passMap.end()) { MT_PASS_INFO& pass_info = pass_data->second; for (size_t i = 0; i < pass_info.attachments.size(); ++i) { MT_FB_ATTACHMENT_INFO& fb_info = my_data->fbMap[pass_info.fb].attachments[i]; if (pass_info.attachments[i].store_op == VK_ATTACHMENT_STORE_OP_STORE) { if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, fb_info.mem, true, fb_info.image); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } } else if (pass_info.attachments[i].store_op == VK_ATTACHMENT_STORE_OP_DONT_CARE) { if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { set_memory_valid(my_data, fb_info.mem, false, fb_info.image); return VK_FALSE; }; cb_data->second.validate_functions.push_back(function); } } } } } loader_platform_thread_unlock_mutex(&globalLock); my_data->device_dispatch_table->CmdEndRenderPass(cmdBuffer); } VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( VkDevice dev, const char *funcName) { if (!strcmp(funcName, "vkGetDeviceProcAddr")) return (PFN_vkVoidFunction) vkGetDeviceProcAddr; if (!strcmp(funcName, "vkDestroyDevice")) return (PFN_vkVoidFunction) vkDestroyDevice; if (!strcmp(funcName, "vkQueueSubmit")) return (PFN_vkVoidFunction) vkQueueSubmit; if (!strcmp(funcName, "vkAllocateMemory")) return (PFN_vkVoidFunction) vkAllocateMemory; if (!strcmp(funcName, "vkFreeMemory")) return (PFN_vkVoidFunction) vkFreeMemory; if (!strcmp(funcName, "vkMapMemory")) return (PFN_vkVoidFunction) vkMapMemory; if (!strcmp(funcName, "vkUnmapMemory")) return (PFN_vkVoidFunction) vkUnmapMemory; if (!strcmp(funcName, "vkFlushMappedMemoryRanges")) return (PFN_vkVoidFunction) vkFlushMappedMemoryRanges; if (!strcmp(funcName, "vkInvalidateMappedMemoryRanges")) return (PFN_vkVoidFunction) vkInvalidateMappedMemoryRanges; if (!strcmp(funcName, "vkDestroyFence")) return (PFN_vkVoidFunction) vkDestroyFence; if (!strcmp(funcName, "vkDestroyBuffer")) return (PFN_vkVoidFunction) vkDestroyBuffer; if (!strcmp(funcName, "vkDestroyImage")) return (PFN_vkVoidFunction) vkDestroyImage; if (!strcmp(funcName, "vkBindBufferMemory")) return (PFN_vkVoidFunction) vkBindBufferMemory; if (!strcmp(funcName, "vkBindImageMemory")) return (PFN_vkVoidFunction) vkBindImageMemory; if (!strcmp(funcName, "vkGetBufferMemoryRequirements")) return (PFN_vkVoidFunction) vkGetBufferMemoryRequirements; if (!strcmp(funcName, "vkGetImageMemoryRequirements")) return (PFN_vkVoidFunction) vkGetImageMemoryRequirements; if (!strcmp(funcName, "vkQueueBindSparse")) return (PFN_vkVoidFunction) vkQueueBindSparse; if (!strcmp(funcName, "vkCreateFence")) return (PFN_vkVoidFunction) vkCreateFence; if (!strcmp(funcName, "vkGetFenceStatus")) return (PFN_vkVoidFunction) vkGetFenceStatus; if (!strcmp(funcName, "vkResetFences")) return (PFN_vkVoidFunction) vkResetFences; if (!strcmp(funcName, "vkWaitForFences")) return (PFN_vkVoidFunction) vkWaitForFences; if (!strcmp(funcName, "vkCreateSemaphore")) return (PFN_vkVoidFunction) vkCreateSemaphore; if (!strcmp(funcName, "vkDestroySemaphore")) return (PFN_vkVoidFunction) vkDestroySemaphore; if (!strcmp(funcName, "vkQueueWaitIdle")) return (PFN_vkVoidFunction) vkQueueWaitIdle; if (!strcmp(funcName, "vkDeviceWaitIdle")) return (PFN_vkVoidFunction) vkDeviceWaitIdle; if (!strcmp(funcName, "vkCreateBuffer")) return (PFN_vkVoidFunction) vkCreateBuffer; if (!strcmp(funcName, "vkCreateImage")) return (PFN_vkVoidFunction) vkCreateImage; if (!strcmp(funcName, "vkCreateImageView")) return (PFN_vkVoidFunction) vkCreateImageView; if (!strcmp(funcName, "vkCreateBufferView")) return (PFN_vkVoidFunction) vkCreateBufferView; if (!strcmp(funcName, "vkUpdateDescriptorSets")) return (PFN_vkVoidFunction) vkUpdateDescriptorSets; if (!strcmp(funcName, "vkAllocateCommandBuffers")) return (PFN_vkVoidFunction) vkAllocateCommandBuffers; if (!strcmp(funcName, "vkFreeCommandBuffers")) return (PFN_vkVoidFunction) vkFreeCommandBuffers; if (!strcmp(funcName, "vkCreateCommandPool")) return (PFN_vkVoidFunction) vkCreateCommandPool; if (!strcmp(funcName, "vkDestroyCommandPool")) return (PFN_vkVoidFunction) vkDestroyCommandPool; if (!strcmp(funcName, "vkResetCommandPool")) return (PFN_vkVoidFunction) vkResetCommandPool; if (!strcmp(funcName, "vkBeginCommandBuffer")) return (PFN_vkVoidFunction) vkBeginCommandBuffer; if (!strcmp(funcName, "vkEndCommandBuffer")) return (PFN_vkVoidFunction) vkEndCommandBuffer; if (!strcmp(funcName, "vkResetCommandBuffer")) return (PFN_vkVoidFunction) vkResetCommandBuffer; if (!strcmp(funcName, "vkCmdBindPipeline")) return (PFN_vkVoidFunction) vkCmdBindPipeline; if (!strcmp(funcName, "vkCmdBindDescriptorSets")) return (PFN_vkVoidFunction) vkCmdBindDescriptorSets; if (!strcmp(funcName, "vkCmdBindVertexBuffers")) return (PFN_vkVoidFunction) vkCmdBindVertexBuffers; if (!strcmp(funcName, "vkCmdBindIndexBuffer")) return (PFN_vkVoidFunction) vkCmdBindIndexBuffer; if (!strcmp(funcName, "vkCmdDraw")) return (PFN_vkVoidFunction) vkCmdDraw; if (!strcmp(funcName, "vkCmdDrawIndexed")) return (PFN_vkVoidFunction) vkCmdDrawIndexed; if (!strcmp(funcName, "vkCmdDrawIndirect")) return (PFN_vkVoidFunction) vkCmdDrawIndirect; if (!strcmp(funcName, "vkCmdDrawIndexedIndirect")) return (PFN_vkVoidFunction) vkCmdDrawIndexedIndirect; if (!strcmp(funcName, "vkCmdDispatch")) return (PFN_vkVoidFunction)vkCmdDispatch; if (!strcmp(funcName, "vkCmdDispatchIndirect")) return (PFN_vkVoidFunction)vkCmdDispatchIndirect; if (!strcmp(funcName, "vkCmdCopyBuffer")) return (PFN_vkVoidFunction)vkCmdCopyBuffer; if (!strcmp(funcName, "vkCmdCopyQueryPoolResults")) return (PFN_vkVoidFunction)vkCmdCopyQueryPoolResults; if (!strcmp(funcName, "vkCmdCopyImage")) return (PFN_vkVoidFunction) vkCmdCopyImage; if (!strcmp(funcName, "vkCmdCopyBufferToImage")) return (PFN_vkVoidFunction) vkCmdCopyBufferToImage; if (!strcmp(funcName, "vkCmdCopyImageToBuffer")) return (PFN_vkVoidFunction) vkCmdCopyImageToBuffer; if (!strcmp(funcName, "vkCmdUpdateBuffer")) return (PFN_vkVoidFunction) vkCmdUpdateBuffer; if (!strcmp(funcName, "vkCmdFillBuffer")) return (PFN_vkVoidFunction) vkCmdFillBuffer; if (!strcmp(funcName, "vkCmdClearColorImage")) return (PFN_vkVoidFunction) vkCmdClearColorImage; if (!strcmp(funcName, "vkCmdClearDepthStencilImage")) return (PFN_vkVoidFunction) vkCmdClearDepthStencilImage; if (!strcmp(funcName, "vkCmdResolveImage")) return (PFN_vkVoidFunction) vkCmdResolveImage; if (!strcmp(funcName, "vkCmdBeginQuery")) return (PFN_vkVoidFunction) vkCmdBeginQuery; if (!strcmp(funcName, "vkCmdEndQuery")) return (PFN_vkVoidFunction) vkCmdEndQuery; if (!strcmp(funcName, "vkCmdResetQueryPool")) return (PFN_vkVoidFunction) vkCmdResetQueryPool; if (!strcmp(funcName, "vkCreateRenderPass")) return (PFN_vkVoidFunction) vkCreateRenderPass; if (!strcmp(funcName, "vkDestroyRenderPass")) return (PFN_vkVoidFunction) vkDestroyRenderPass; if (!strcmp(funcName, "vkCmdBeginRenderPass")) return (PFN_vkVoidFunction) vkCmdBeginRenderPass; if (!strcmp(funcName, "vkCmdEndRenderPass")) return (PFN_vkVoidFunction) vkCmdEndRenderPass; if (!strcmp(funcName, "vkGetDeviceQueue")) return (PFN_vkVoidFunction) vkGetDeviceQueue; if (!strcmp(funcName, "vkCreateFramebuffer")) return (PFN_vkVoidFunction) vkCreateFramebuffer; if (!strcmp(funcName, "vkDestroyFramebuffer")) return (PFN_vkVoidFunction) vkDestroyFramebuffer; if (dev == NULL) return NULL; layer_data *my_data; my_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map); if (my_data->wsi_enabled) { if (!strcmp(funcName, "vkCreateSwapchainKHR")) return (PFN_vkVoidFunction) vkCreateSwapchainKHR; if (!strcmp(funcName, "vkDestroySwapchainKHR")) return (PFN_vkVoidFunction) vkDestroySwapchainKHR; if (!strcmp(funcName, "vkGetSwapchainImagesKHR")) return (PFN_vkVoidFunction) vkGetSwapchainImagesKHR; if (!strcmp(funcName, "vkAcquireNextImageKHR")) return (PFN_vkVoidFunction)vkAcquireNextImageKHR; if (!strcmp(funcName, "vkQueuePresentKHR")) return (PFN_vkVoidFunction)vkQueuePresentKHR; } VkLayerDispatchTable *pDisp = my_data->device_dispatch_table; if (pDisp->GetDeviceProcAddr == NULL) return NULL; return pDisp->GetDeviceProcAddr(dev, funcName); } VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( VkInstance instance, const char *funcName) { PFN_vkVoidFunction fptr; if (!strcmp(funcName, "vkGetInstanceProcAddr")) return (PFN_vkVoidFunction) vkGetInstanceProcAddr; if (!strcmp(funcName, "vkGetDeviceProcAddr")) return (PFN_vkVoidFunction) vkGetDeviceProcAddr; if (!strcmp(funcName, "vkDestroyInstance")) return (PFN_vkVoidFunction) vkDestroyInstance; if (!strcmp(funcName, "vkCreateInstance")) return (PFN_vkVoidFunction) vkCreateInstance; if (!strcmp(funcName, "vkGetPhysicalDeviceMemoryProperties")) return (PFN_vkVoidFunction) vkGetPhysicalDeviceMemoryProperties; if (!strcmp(funcName, "vkCreateDevice")) return (PFN_vkVoidFunction) vkCreateDevice; if (!strcmp(funcName, "vkEnumerateInstanceLayerProperties")) return (PFN_vkVoidFunction) vkEnumerateInstanceLayerProperties; if (!strcmp(funcName, "vkEnumerateInstanceExtensionProperties")) return (PFN_vkVoidFunction) vkEnumerateInstanceExtensionProperties; if (!strcmp(funcName, "vkEnumerateDeviceLayerProperties")) return (PFN_vkVoidFunction) vkEnumerateDeviceLayerProperties; if (!strcmp(funcName, "vkEnumerateDeviceExtensionProperties")) return (PFN_vkVoidFunction) vkEnumerateDeviceExtensionProperties; if (instance == NULL) return NULL; layer_data *my_data; my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); fptr = debug_report_get_instance_proc_addr(my_data->report_data, funcName); if (fptr) return fptr; VkLayerInstanceDispatchTable* pTable = my_data->instance_dispatch_table; if (pTable->GetInstanceProcAddr == NULL) return NULL; return pTable->GetInstanceProcAddr(instance, funcName); }