mem_tracker: add per-instance persistent data
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 82ed573..a85931e 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -43,9 +43,16 @@
#include "layers_table.h"
#include "layer_data.h"
#include "layer_logging.h"
+ static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
-static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
+typedef struct _layer_data {
+ debug_report_data *report_data;
+ // TODO: put instance data here
+} layer_data;
+static std::unordered_map<void *, layer_data *> layer_data_map;
+static device_table_map mem_tracker_device_table_map;
+static instance_table_map mem_tracker_instance_table_map;
// TODO : This can be much smarter, using separate locks for separate global data
static int globalLockInitialized = 0;
@@ -63,6 +70,25 @@
// TODO : Add per-device fence completion
static uint64_t g_currentFenceId = 1;
+template layer_data *get_my_data_ptr<layer_data>(
+ void *data_key,
+ std::unordered_map<void *, layer_data *> &data_map);
+
+debug_report_data *mdd(VkObject object)
+{
+// VkLayerDispatchTable *pTable = get_dispatch_table(mem_tracker_device_table_map, object);
+// layer_data *my_data = get_my_data_ptr(pTable, layer_data_map);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(object), layer_data_map);
+ return my_data->report_data;
+}
+
+debug_report_data *mid(VkInstance object)
+{
+// VkLayerInstanceDispatchTable *pTable = get_dispatch_table(mem_tracker_instance_table_map, object);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(object), layer_data_map);
+ return my_data->report_data;
+}
+
// Add new queue for this device to map container
static void add_queue_info(const VkQueue queue)
{
@@ -152,7 +178,7 @@
if (pObjectInfo->create_info.fence_create_info.flags & VK_FENCE_CREATE_SIGNALED_BIT) {
char str[1024];
sprintf(str, "Fence %p submitted in SIGNALED state. Fences must be reset before being submitted", fence);
- device_log_msg(queue, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
+ device_log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
}
}
}
@@ -262,7 +288,7 @@
char str[1024];
sprintf(str, "Trying to bind mem obj %p to CB %p but no info for that mem obj.\n "
"Was it correctly allocated? Did it already get freed?", mem, cb);
- device_log_msg(cb, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+ device_log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
result = VK_FALSE;
} else {
// Search for cmd buffer object in memory object's binding list
@@ -287,7 +313,7 @@
if (!pCBInfo) {
char str[1024];
sprintf(str, "Trying to bind mem obj %p to CB %p but no info for that CB. Was CB incorrectly destroyed?", mem, cb);
- device_log_msg(cb, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+ device_log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
result = VK_FALSE;
} else {
// Search for memory object in cmd buffer's reference list
@@ -334,7 +360,7 @@
if (!pCBInfo) {
char str[1024];
sprintf(str, "Unable to find global CB info %p for deletion", cb);
- device_log_msg(cb, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
+ device_log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
result = VK_FALSE;
} else {
if (pCBInfo->pMemObjList.size() > 0) {
@@ -384,14 +410,14 @@
char str[1024];
sprintf(str, "Attempting to free memory object %p which still contains %lu references",
pMemObjInfo->mem, (cmdBufRefCount + objRefCount));
- device_log_msg(pMemObjInfo->object, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, pMemObjInfo->mem, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+ device_log_msg(mdd(pMemObjInfo->object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, pMemObjInfo->mem, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
}
if (cmdBufRefCount > 0 && pMemObjInfo->pCmdBufferBindings.size() > 0) {
for (list<VkCmdBuffer>::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) {
char str[1024];
sprintf(str, "Command Buffer %p still has a reference to mem obj %p", (*it), pMemObjInfo->mem);
- device_log_msg(pMemObjInfo->object, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (*it), 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(pMemObjInfo->object), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (*it), 0, MEMTRACK_NONE, "MEM", str);
}
// Clear the list of hanging references
pMemObjInfo->pCmdBufferBindings.clear();
@@ -402,7 +428,7 @@
char str[1024];
sprintf(str, "VK Object %p still has a reference to mem obj %p", (*it), pMemObjInfo->mem);
/* TODO: Would be nice to return the actual object type */
- device_log_msg(pMemObjInfo->object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, (*it), 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(pMemObjInfo->object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, (*it), 0, MEMTRACK_NONE, "MEM", str);
}
// Clear the list of hanging references
pMemObjInfo->pObjBindings.clear();
@@ -421,7 +447,7 @@
else {
char str[1024];
sprintf(str, "Request to delete memory object %p not present in memory Object Map", mem);
- device_log_msg(object, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
}
}
@@ -434,7 +460,7 @@
if (!pCBInfo) {
char str[1024];
sprintf(str, "Unable to find global CB info %p to check for completion", cb);
- device_log_msg(cb, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
+ device_log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
result = VK_FALSE;
} else if (pCBInfo->lastSubmittedQueue != NULL) {
VkQueue queue = pCBInfo->lastSubmittedQueue;
@@ -443,7 +469,7 @@
char str[1024];
sprintf(str, "fence %p for CB %p has not been checked for completion",
(void*)pCBInfo->lastSubmittedFence, cb);
- device_log_msg(cb, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_NONE, "MEM", str);
result = VK_FALSE;
}
}
@@ -462,14 +488,14 @@
char str[1024];
sprintf(str, "Couldn't find mem info object for %p\n Was %p never allocated or previously freed?",
(void*)mem, (void*)mem);
- device_log_msg(object, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
result = VK_FALSE;
} else {
if (pInfo->allocInfo.allocationSize == 0 && !internal) {
char str[1024];
sprintf(str, "Attempting to free memory associated with a Persistent Image, %p, "
"this should not be explicitly freed\n", (void*)mem);
- device_log_msg(pInfo->object, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+ device_log_msg(mdd(pInfo->object), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
result = VK_FALSE;
} else {
// Clear any CB bindings for completed CBs
@@ -513,7 +539,7 @@
if (!pObjInfo->pMemObjInfo || pObjInfo->pMemObjInfo->pObjBindings.size() <= 0) {
char str[1024];
sprintf(str, "Attempting to clear mem binding on obj %p but it has no binding.", (void*)object);
- device_log_msg(object, VK_DBG_REPORT_WARN_BIT, (VkObjectType) 0, object, 0, MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_WARN_BIT, (VkObjectType) 0, object, 0, MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS, "MEM", str);
} else {
// 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.
@@ -530,7 +556,7 @@
char str[1024];
sprintf(str, "While trying to clear mem binding for object %p, unable to find that object referenced by mem obj %p",
object, pObjInfo->pMemObjInfo->mem);
- device_log_msg(object, VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
}
}
}
@@ -552,27 +578,27 @@
if (mem == VK_NULL_HANDLE) {
char str[1024];
sprintf(str, "Attempting to Bind Obj(%p) to NULL", (void*)object);
- device_log_msg(object, VK_DBG_REPORT_WARN_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_WARN_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
return VK_TRUE;
} else {
char str[1024];
MT_OBJ_INFO* pObjInfo = get_object_info(object);
if (!pObjInfo) {
sprintf(str, "Attempting to update Binding of Obj(%p) that's not in global list()", (void*)object);
- device_log_msg(object, VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
return VK_FALSE;
}
// non-null case so should have real mem obj
MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem);
if (!pInfo) {
sprintf(str, "While trying to bind mem for obj %p, couldn't find info for mem obj %p", (void*)object, (void*)mem);
- device_log_msg(object, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
return VK_FALSE;
} else {
if (pObjInfo->pMemObjInfo != NULL) {
sprintf(str, "Attempting to bind memory (%p) to object (%p) which has already been bound to mem object %p",
(void*)mem, (void*)object, (void*)pObjInfo->pMemObjInfo->mem);
- device_log_msg(object, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_REBIND_OBJECT, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_REBIND_OBJECT, "MEM", str);
return VK_FALSE;
}
else {
@@ -614,14 +640,14 @@
MT_OBJ_INFO* pObjInfo = get_object_info(object);
if (!pObjInfo) {
sprintf(str, "Attempting to update Binding of Obj(%p) that's not in global list()", (void*)object);
- device_log_msg(object, VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
return VK_FALSE;
}
// non-null case so should have real mem obj
MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem);
if (!pInfo) {
sprintf(str, "While trying to bind mem for obj %p, couldn't find info for mem obj %p", (void*)object, (void*)mem);
- device_log_msg(object, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
return VK_FALSE;
} else {
// Search for object in memory object's binding list
@@ -643,7 +669,7 @@
if (pObjInfo->pMemObjInfo) {
clear_object_binding(object); // Need to clear the previous object binding before setting new binding
sprintf(str, "Updating memory binding for object %p from mem obj %p to %p", object, pObjInfo->pMemObjInfo->mem, mem);
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, object, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, object, 0, MEMTRACK_NONE, "MEM", str);
}
pObjInfo->pMemObjInfo = pInfo;
}
@@ -658,13 +684,13 @@
MT_OBJ_INFO* pInfo = NULL;
char str[1024];
sprintf(str, "Details of Object list of size %lu elements", objectMap.size());
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
if (objectMap.size() <= 0)
return;
for (unordered_map<VkObject, MT_OBJ_INFO>::iterator ii=objectMap.begin(); ii!=objectMap.end(); ++ii) {
pInfo = &(*ii).second;
sprintf(str, " ObjInfo %p has object %p, pMemObjInfo %p", pInfo, pInfo->object, pInfo->pMemObjInfo);
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, pInfo->object, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, pInfo->object, 0, MEMTRACK_NONE, "MEM", str);
}
}
@@ -680,13 +706,13 @@
} else {
char str[1024];
sprintf(str, "Trying to get mem binding for object %p but object has no mem binding", (void*)object);
- device_log_msg(object, VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", str);
print_object_list(object);
}
} else {
char str[1024];
sprintf(str, "Trying to get mem binding for object %p but no such object in global list", (void*)object);
- device_log_msg(object, VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
print_object_list(object);
}
return mem;
@@ -700,7 +726,7 @@
// Just printing each msg individually for now, may want to package these into single large print
char str[1024];
sprintf(str, "MEM INFO : Details of Memory Object list of size %lu elements", memObjMap.size());
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
if (memObjMap.size() <= 0)
return;
@@ -709,36 +735,36 @@
pInfo = &(*ii).second;
sprintf(str, " ===MemObjInfo at %p===", (void*)pInfo);
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
sprintf(str, " Mem object: %p", (void*)pInfo->mem);
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
sprintf(str, " Ref Count: %u", pInfo->refCount);
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
if (0 != pInfo->allocInfo.allocationSize) {
string pAllocInfoMsg = vk_print_vkmemoryallocinfo(&pInfo->allocInfo, "{MEM}INFO : ");
sprintf(str, " Mem Alloc info:\n%s", pAllocInfoMsg.c_str());
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
} else {
sprintf(str, " Mem Alloc info is NULL (alloc done by vkCreateSwapChainWSI())");
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
}
sprintf(str, " VK OBJECT Binding list of size %lu elements:", pInfo->pObjBindings.size());
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
if (pInfo->pObjBindings.size() > 0) {
for (list<VkObject>::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) {
sprintf(str, " VK OBJECT %p", (*it));
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
}
}
sprintf(str, " VK Command Buffer (CB) binding list of size %lu elements", pInfo->pCmdBufferBindings.size());
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
if (pInfo->pCmdBufferBindings.size() > 0)
{
for (list<VkCmdBuffer>::iterator it = pInfo->pCmdBufferBindings.begin(); it != pInfo->pCmdBufferBindings.end(); ++it) {
sprintf(str, " VK CB %p", (*it));
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
}
}
}
@@ -750,7 +776,7 @@
char str[1024];
MT_CB_INFO* pCBInfo = NULL;
sprintf(str, "Details of CB list of size %lu elements", cbMap.size());
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
if (cbMap.size() <= 0)
return;
@@ -761,13 +787,13 @@
sprintf(str, " CB Info (%p) has CB %p, fenceId %" PRIx64", and fence %p",
(void*)pCBInfo, (void*)pCBInfo->cmdBuffer, pCBInfo->fenceId,
(void*)pCBInfo->lastSubmittedFence);
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
if (pCBInfo->pMemObjList.size() <= 0)
continue;
for (list<VkDeviceMemory>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
sprintf(str, " Mem obj %p", (*it));
- device_log_msg(object, VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(object), VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
}
}
}
@@ -808,10 +834,14 @@
// hook DestroyInstance to remove tableInstanceMap entry
VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance)
{
- VkLayerInstanceDispatchTable *pDisp = *(VkLayerInstanceDispatchTable **) instance;
- VkResult res = instance_dispatch_table(instance)->DestroyInstance(instance);
- layer_debug_report_destroy_instance(instance);
- tableInstanceMap.erase(pDisp);
+ dispatch_key key = get_dispatch_key(instance);
+ VkLayerInstanceDispatchTable *pTable = get_dispatch_table(mem_tracker_instance_table_map, instance);
+ VkResult res = pTable->DestroyInstance(instance);
+ layer_debug_report_destroy_instance(mid(instance));
+ layer_data_map.erase(pTable);
+
+ mem_tracker_instance_table_map.erase(key);
+ assert(mem_tracker_instance_table_map.size() == 0 && "Should not have any instance mappings hanging around");
return res;
}
@@ -821,19 +851,16 @@
{
loader_platform_thread_once(&g_initOnce, initMemTracker);
- VkLayerInstanceDispatchTable *pTable = instance_dispatch_table(*pInstance);
+ VkLayerInstanceDispatchTable *pTable = get_dispatch_table(mem_tracker_instance_table_map, *pInstance);
VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
if (result == VK_SUCCESS) {
- debug_report_create_instance(
- pTable,
- pCreateInfo->extensionCount,
- pCreateInfo->pEnabledExtensions);
-
- debug_report_init_instance_extension_dispatch_table(
- pTable,
- pTable->GetInstanceProcAddr,
- *pInstance);
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
+ my_data->report_data = debug_report_create_instance(
+ pTable,
+ *pInstance,
+ pCreateInfo->extensionCount,
+ pCreateInfo->pEnabledExtensions);
}
return result;
}
@@ -843,9 +870,13 @@
const VkDeviceCreateInfo *pCreateInfo,
VkDevice *pDevice)
{
- VkResult result = instance_dispatch_table(gpu)->CreateDevice(gpu, pCreateInfo, pDevice);
+ VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(mem_tracker_instance_table_map, gpu);
+ VkResult result = pInstanceTable->CreateDevice(gpu, pCreateInfo, pDevice);
if (result == VK_SUCCESS) {
- layer_debug_report_create_device(instance_dispatch_table(gpu), *pDevice);
+ layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
+ VkLayerDispatchTable *pTable = get_dispatch_table(mem_tracker_device_table_map, *pDevice);
+ layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
+ my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
}
return result;
}
@@ -856,13 +887,13 @@
char str[1024];
sprintf(str, "Printing List details prior to vkDestroyDevice()");
loader_platform_thread_lock_mutex(&globalLock);
- device_log_msg(device, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE, device, 0, MEMTRACK_NONE, "MEM", str);
+ device_log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE, device, 0, MEMTRACK_NONE, "MEM", str);
print_mem_list(device);
printCBList(device);
print_object_list(device);
if (VK_FALSE == delete_cmd_buf_info_list()) {
sprintf(str, "Issue deleting global CB list in vkDestroyDevice()");
- device_log_msg(device, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, device, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
+ device_log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, device, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
}
// Report any memory leaks
MT_MEM_OBJ_INFO* pInfo = NULL;
@@ -873,7 +904,7 @@
if (pInfo->allocInfo.allocationSize != 0) {
sprintf(str, "Mem Object %p has not been freed. You should clean up this memory by calling "
"vkFreeMemory(%p) prior to vkDestroyDevice().", pInfo->mem, pInfo->mem);
- device_log_msg(device, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, pInfo->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM", str);
+ device_log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, pInfo->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM", str);
}
}
}
@@ -885,9 +916,10 @@
loader_platform_thread_unlock_mutex(&globalLock);
- VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
- VkResult result = device_dispatch_table(device)->DestroyDevice(device);
- tableMap.erase(pDisp);
+ dispatch_key key = get_dispatch_key(device);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyDevice(device);
+ mem_tracker_device_table_map.erase(key);
+ assert(mem_tracker_instance_table_map.size() == 0 && "Should not have any instance mappings hanging around");
return result;
}
@@ -995,7 +1027,7 @@
uint32_t queueIndex,
VkQueue *pQueue)
{
- VkResult result = device_dispatch_table(device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
add_queue_info(*pQueue);
@@ -1025,7 +1057,7 @@
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = device_dispatch_table(queue)->QueueSubmit(
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, queue)->QueueSubmit(
queue, cmdBufferCount, pCmdBuffers, fence);
return result;
}
@@ -1035,7 +1067,7 @@
const VkMemoryAllocInfo *pAllocInfo,
VkDeviceMemory *pMem)
{
- VkResult result = device_dispatch_table(device)->AllocMemory(device, pAllocInfo, pMem);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->AllocMemory(device, pAllocInfo, pMem);
// TODO : Track allocations and overall size here
loader_platform_thread_lock_mutex(&globalLock);
add_mem_obj_info(device, *pMem, pAllocInfo);
@@ -1061,10 +1093,10 @@
if (noerror == VK_FALSE) {
char str[1024];
sprintf(str, "Freeing memory object while it still has references: mem obj %p", (void*)mem);
- device_log_msg(device, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_FREED_MEM_REF, "MEM", str);
+ device_log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_FREED_MEM_REF, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = device_dispatch_table(device)->FreeMemory(device, mem);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->FreeMemory(device, mem);
return result;
}
@@ -1075,7 +1107,7 @@
{
// TODO : Update tracking for this alloc
// Make sure memory is not pinned, which can't have priority set
- VkResult result = device_dispatch_table(device)->SetMemoryPriority(device, mem, priority);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->SetMemoryPriority(device, mem, priority);
return result;
}
@@ -1093,10 +1125,10 @@
if ((pMemObj->allocInfo.memProps & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0) {
char str[1024];
sprintf(str, "Mapping Memory without VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT set: mem obj %p", (void*)mem);
- device_log_msg(device, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str);
+ device_log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = device_dispatch_table(device)->MapMemory(device, mem, offset, size, flags, ppData);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->MapMemory(device, mem, offset, size, flags, ppData);
return result;
}
@@ -1106,7 +1138,7 @@
{
// TODO : Track as memory gets unmapped, do we want to check what changed following map?
// Make sure that memory was ever mapped to begin with
- VkResult result = device_dispatch_table(device)->UnmapMemory(device, mem);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->UnmapMemory(device, mem);
return result;
}
@@ -1118,7 +1150,7 @@
{
// TODO : Track this
// Verify that memory is actually pinnable
- VkResult result = device_dispatch_table(device)->PinSystemMemory(device, pSysMem, memSize, pMem);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->PinSystemMemory(device, pSysMem, memSize, pMem);
return result;
}
@@ -1128,7 +1160,7 @@
VkDeviceMemory *pMem)
{
// TODO : Track this
- VkResult result = device_dispatch_table(device)->OpenSharedMemory(device, pOpenInfo, pMem);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->OpenSharedMemory(device, pOpenInfo, pMem);
return result;
}
@@ -1138,7 +1170,7 @@
VkDeviceMemory *pMem)
{
// TODO : Track this
- VkResult result = device_dispatch_table(device)->OpenPeerMemory(device, pOpenInfo, pMem);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->OpenPeerMemory(device, pOpenInfo, pMem);
return result;
}
@@ -1149,7 +1181,7 @@
VkDeviceMemory *pMem)
{
// TODO : Track this
- VkResult result = device_dispatch_table(device)->OpenPeerImage(device, pOpenInfo, pImage, pMem);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->OpenPeerImage(device, pOpenInfo, pImage, pMem);
return result;
}
@@ -1191,7 +1223,7 @@
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = device_dispatch_table(device)->DestroyObject(device, objType, object);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DestroyObject(device, objType, object);
return result;
}
@@ -1207,7 +1239,7 @@
// Could potentially save returned mem requirements and validate values passed into BindObjectMemory for this object
// From spec : The only objects that are guaranteed to have no external memory requirements are devices, queues,
// command buffers, shaders and memory objects.
- VkResult result = device_dispatch_table(device)->GetObjectInfo(device, objType, object, infoType, pDataSize, pData);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->GetObjectInfo(device, objType, object, infoType, pDataSize, pData);
return result;
}
@@ -1218,7 +1250,7 @@
VkDeviceMemory mem,
VkDeviceSize offset)
{
- VkResult result = device_dispatch_table(device)->BindObjectMemory(device, objType, object, mem, offset);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->BindObjectMemory(device, objType, object, mem, offset);
loader_platform_thread_lock_mutex(&globalLock);
// Track objects tied to memory
set_object_binding(object, mem);
@@ -1236,14 +1268,14 @@
VkDeviceMemory mem,
VkDeviceSize memOffset)
{
- VkResult result = device_dispatch_table(queue)->QueueBindSparseBufferMemory(
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, queue)->QueueBindSparseBufferMemory(
queue, buffer, rangeOffset, rangeSize, mem, memOffset);
loader_platform_thread_lock_mutex(&globalLock);
// Track objects tied to memory
if (VK_FALSE == set_sparse_buffer_binding(buffer, mem)) {
char str[1024];
sprintf(str, "Unable to set object %p binding to mem obj %p", (void*)buffer, (void*)mem);
- device_log_msg(queue, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER, buffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER, buffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
print_object_list(queue);
print_mem_list(queue);
@@ -1256,7 +1288,7 @@
const VkFenceCreateInfo *pCreateInfo,
VkFence *pFence)
{
- VkResult result = device_dispatch_table(device)->CreateFence(device, pCreateInfo, pFence);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateFence(device, pCreateInfo, pFence);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pFence, pCreateInfo->sType, pCreateInfo, sizeof(VkFenceCreateInfo), "fence");
@@ -1274,7 +1306,7 @@
* TODO: Shouldn't we check for error conditions before passing down the chain?
* What if reason result is not VK_SUCCESS is something we could report as a validation error?
*/
- VkResult result = device_dispatch_table(device)->ResetFences(device, fenceCount, pFences);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->ResetFences(device, fenceCount, pFences);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
// Reset fence state in fenceCreateInfo structure
@@ -1285,7 +1317,7 @@
if (!(pObjectInfo->create_info.fence_create_info.flags & VK_FENCE_CREATE_SIGNALED_BIT)) {
char str[1024];
sprintf(str, "Fence %p submitted to VkResetFences in UNSIGNALED STATE", pFences[i]);
- device_log_msg(device, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
+ device_log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
result = VK_ERROR_INVALID_VALUE;
}
else {
@@ -1303,7 +1335,7 @@
VkDevice device,
VkFence fence)
{
- VkResult result = device_dispatch_table(device)->GetFenceStatus(device, fence);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->GetFenceStatus(device, fence);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
update_fence_tracking(fence);
@@ -1326,12 +1358,12 @@
if (pObjectInfo->create_info.fence_create_info.flags & VK_FENCE_CREATE_SIGNALED_BIT) {
char str[1024];
sprintf(str, "VkWaitForFences specified fence %p already in SIGNALED state.", pFences[i]);
- device_log_msg(device, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
+ device_log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
}
}
}
- VkResult result = device_dispatch_table(device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
loader_platform_thread_lock_mutex(&globalLock);
if (VK_SUCCESS == result) {
@@ -1348,7 +1380,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(
VkQueue queue)
{
- VkResult result = device_dispatch_table(queue)->QueueWaitIdle(queue);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, queue)->QueueWaitIdle(queue);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
retire_queue_fences(queue);
@@ -1360,7 +1392,7 @@
VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(
VkDevice device)
{
- VkResult result = device_dispatch_table(device)->DeviceWaitIdle(device);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->DeviceWaitIdle(device);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
retire_device_fences(device);
@@ -1374,7 +1406,7 @@
const VkEventCreateInfo *pCreateInfo,
VkEvent *pEvent)
{
- VkResult result = device_dispatch_table(device)->CreateEvent(device, pCreateInfo, pEvent);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateEvent(device, pCreateInfo, pEvent);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pEvent, pCreateInfo->sType, pCreateInfo, sizeof(VkEventCreateInfo), "event");
@@ -1388,7 +1420,7 @@
const VkQueryPoolCreateInfo *pCreateInfo,
VkQueryPool *pQueryPool)
{
- VkResult result = device_dispatch_table(device)->CreateQueryPool(device, pCreateInfo, pQueryPool);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateQueryPool(device, pCreateInfo, pQueryPool);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pQueryPool, pCreateInfo->sType, pCreateInfo, sizeof(VkQueryPoolCreateInfo), "query_pool");
@@ -1402,7 +1434,7 @@
const VkBufferCreateInfo *pCreateInfo,
VkBuffer *pBuffer)
{
- VkResult result = device_dispatch_table(device)->CreateBuffer(device, pCreateInfo, pBuffer);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateBuffer(device, pCreateInfo, pBuffer);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferCreateInfo), "buffer");
@@ -1416,7 +1448,7 @@
const VkBufferViewCreateInfo *pCreateInfo,
VkBufferView *pView)
{
- VkResult result = device_dispatch_table(device)->CreateBufferView(device, pCreateInfo, pView);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateBufferView(device, pCreateInfo, pView);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferViewCreateInfo), "buffer_view");
@@ -1430,7 +1462,7 @@
const VkImageCreateInfo *pCreateInfo,
VkImage *pImage)
{
- VkResult result = device_dispatch_table(device)->CreateImage(device, pCreateInfo, pImage);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateImage(device, pCreateInfo, pImage);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pImage, pCreateInfo->sType, pCreateInfo, sizeof(VkImageCreateInfo), "image");
@@ -1444,7 +1476,7 @@
const VkImageViewCreateInfo *pCreateInfo,
VkImageView *pView)
{
- VkResult result = device_dispatch_table(device)->CreateImageView(device, pCreateInfo, pView);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateImageView(device, pCreateInfo, pView);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkImageViewCreateInfo), "image_view");
@@ -1458,7 +1490,7 @@
const VkColorAttachmentViewCreateInfo *pCreateInfo,
VkColorAttachmentView *pView)
{
- VkResult result = device_dispatch_table(device)->CreateColorAttachmentView(device, pCreateInfo, pView);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateColorAttachmentView(device, pCreateInfo, pView);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkColorAttachmentViewCreateInfo), "color_attachment_view");
@@ -1472,7 +1504,7 @@
const VkDepthStencilViewCreateInfo *pCreateInfo,
VkDepthStencilView *pView)
{
- VkResult result = device_dispatch_table(device)->CreateDepthStencilView(device, pCreateInfo, pView);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDepthStencilView(device, pCreateInfo, pView);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkDepthStencilViewCreateInfo), "ds_view");
@@ -1486,7 +1518,7 @@
const VkShaderCreateInfo *pCreateInfo,
VkShader *pShader)
{
- VkResult result = device_dispatch_table(device)->CreateShader(device, pCreateInfo, pShader);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateShader(device, pCreateInfo, pShader);
return result;
}
@@ -1495,7 +1527,7 @@
const VkGraphicsPipelineCreateInfo *pCreateInfo,
VkPipeline *pPipeline)
{
- VkResult result = device_dispatch_table(device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo), "graphics_pipeline");
@@ -1510,7 +1542,7 @@
VkPipeline basePipeline,
VkPipeline *pPipeline)
{
- VkResult result = device_dispatch_table(device)->CreateGraphicsPipelineDerivative(
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateGraphicsPipelineDerivative(
device, pCreateInfo, basePipeline, pPipeline);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
@@ -1525,7 +1557,7 @@
const VkComputePipelineCreateInfo *pCreateInfo,
VkPipeline *pPipeline)
{
- VkResult result = device_dispatch_table(device)->CreateComputePipeline(device, pCreateInfo, pPipeline);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateComputePipeline(device, pCreateInfo, pPipeline);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkComputePipelineCreateInfo), "compute_pipeline");
@@ -1539,7 +1571,7 @@
const VkSamplerCreateInfo *pCreateInfo,
VkSampler *pSampler)
{
- VkResult result = device_dispatch_table(device)->CreateSampler(device, pCreateInfo, pSampler);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateSampler(device, pCreateInfo, pSampler);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pSampler, pCreateInfo->sType, pCreateInfo, sizeof(VkSamplerCreateInfo), "sampler");
@@ -1553,7 +1585,7 @@
const VkDynamicVpStateCreateInfo *pCreateInfo,
VkDynamicVpState *pState)
{
- VkResult result = device_dispatch_table(device)->CreateDynamicViewportState(device, pCreateInfo, pState);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicViewportState(device, pCreateInfo, pState);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicVpStateCreateInfo), "viewport_state");
@@ -1567,7 +1599,7 @@
const VkDynamicRsStateCreateInfo *pCreateInfo,
VkDynamicRsState *pState)
{
- VkResult result = device_dispatch_table(device)->CreateDynamicRasterState(device, pCreateInfo, pState);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicRsStateCreateInfo), "raster_state");
@@ -1581,7 +1613,7 @@
const VkDynamicCbStateCreateInfo *pCreateInfo,
VkDynamicCbState *pState)
{
- VkResult result = device_dispatch_table(device)->CreateDynamicColorBlendState(device, pCreateInfo, pState);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicColorBlendState(device, pCreateInfo, pState);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicCbStateCreateInfo), "cb_state");
@@ -1595,7 +1627,7 @@
const VkDynamicDsStateCreateInfo *pCreateInfo,
VkDynamicDsState *pState)
{
- VkResult result = device_dispatch_table(device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
if (result == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
add_object_info(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicDsStateCreateInfo), "ds_state");
@@ -1609,7 +1641,7 @@
const VkCmdBufferCreateInfo *pCreateInfo,
VkCmdBuffer *pCmdBuffer)
{
- VkResult result = device_dispatch_table(device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
// At time of cmd buffer creation, create global cmd buffer info for the returned cmd buffer
loader_platform_thread_lock_mutex(&globalLock);
if (*pCmdBuffer)
@@ -1629,10 +1661,10 @@
char str[1024];
sprintf(str, "Calling vkBeginCommandBuffer() on active CB %p before it has completed. "
"You must check CB flag before this call.", cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = device_dispatch_table(cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo);
loader_platform_thread_lock_mutex(&globalLock);
clear_cmd_buf_and_mem_references(cmdBuffer);
loader_platform_thread_unlock_mutex(&globalLock);
@@ -1643,7 +1675,7 @@
VkCmdBuffer cmdBuffer)
{
// TODO : Anything to do here?
- VkResult result = device_dispatch_table(cmdBuffer)->EndCommandBuffer(cmdBuffer);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->EndCommandBuffer(cmdBuffer);
return result;
}
@@ -1656,12 +1688,12 @@
char str[1024];
sprintf(str, "Resetting CB %p before it has completed. You must check CB flag before "
"calling vkResetCommandBuffer().", cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
}
// Clear memory references as this point.
clear_cmd_buf_and_mem_references(cmdBuffer);
loader_platform_thread_unlock_mutex(&globalLock);
- VkResult result = device_dispatch_table(cmdBuffer)->ResetCommandBuffer(cmdBuffer);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->ResetCommandBuffer(cmdBuffer);
return result;
}
// TODO : For any vkCmdBind* calls that include an object which has mem bound to it,
@@ -1689,7 +1721,7 @@
layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline, 0, MEMTRACK_INVALID_OBJECT, (char *) "DS", (char *) str);
}
#endif
- device_dispatch_table(cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
}
VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(
@@ -1703,18 +1735,18 @@
if (!pCmdBuf) {
char str[1024];
sprintf(str, "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_INVALID_CB, "DD", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_INVALID_CB, "DD", str);
}
pObjInfo = get_object_info(state);
if (!pObjInfo) {
char str[1024];
sprintf(str, "Unable to find dynamic state object %p, was it ever created?", (void*)state);
/* TODO: put in real object type */
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, state, 0, MEMTRACK_INVALID_OBJECT, "DD", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, state, 0, MEMTRACK_INVALID_OBJECT, "DD", str);
}
pCmdBuf->pDynamicState[stateBindPoint] = pObjInfo;
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
}
VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
@@ -1727,7 +1759,7 @@
const uint32_t *pDynamicOffsets)
{
// TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state
- device_dispatch_table(cmdBuffer)->CmdBindDescriptorSets(
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindDescriptorSets(
cmdBuffer, pipelineBindPoint, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
@@ -1738,7 +1770,7 @@
const VkBuffer *pBuffers,
const VkDeviceSize *pOffsets)
{
- device_dispatch_table(cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
}
VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(
@@ -1747,7 +1779,7 @@
VkDeviceSize offset,
VkIndexType indexType)
{
- device_dispatch_table(cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
}
VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(
@@ -1762,10 +1794,10 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdDrawIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
}
VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(
@@ -1780,10 +1812,10 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdDrawIndexedIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
}
VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(
@@ -1796,10 +1828,10 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdDispatchIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset);
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(
@@ -1814,16 +1846,16 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdCopyBuffer() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
mem = get_mem_binding_from_object(destBuffer);
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdCopyBuffer() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
}
VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(
@@ -1836,7 +1868,7 @@
const VkImageCopy *pRegions)
{
// TODO : Each image will have mem mapping so track them
- device_dispatch_table(cmdBuffer)->CmdCopyImage(
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdCopyImage(
cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
@@ -1851,7 +1883,7 @@
VkTexFilter filter)
{
// TODO : Each image will have mem mapping so track them
- device_dispatch_table(cmdBuffer)->CmdBlitImage(
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBlitImage(
cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
}
@@ -1869,17 +1901,17 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdCopyMemoryToImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
mem = get_mem_binding_from_object(srcBuffer);
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdCopyMemoryToImage() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdCopyBufferToImage(
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdCopyBufferToImage(
cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
}
@@ -1897,16 +1929,16 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdCopyImageToMemory() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
mem = get_mem_binding_from_object(destBuffer);
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdCopyImageToMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdCopyImageToBuffer(
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdCopyImageToBuffer(
cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
}
@@ -1922,10 +1954,10 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdUpdateMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
}
VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(
@@ -1940,10 +1972,10 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdFillMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
}
VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
@@ -1960,10 +1992,10 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdClearColorImage() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(
@@ -1981,10 +2013,10 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdClearDepthStencil() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdClearDepthStencil(
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdClearDepthStencil(
cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
}
@@ -2002,16 +2034,16 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdResolveImage() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
mem = get_mem_binding_from_object(destImage);
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdResolveImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdResolveImage(
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdResolveImage(
cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
}
@@ -2026,10 +2058,10 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdBeginQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
}
VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(
@@ -2042,10 +2074,10 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdEndQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdEndQuery(cmdBuffer, queryPool, slot);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdEndQuery(cmdBuffer, queryPool, slot);
}
VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(
@@ -2059,10 +2091,10 @@
if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
char str[1024];
sprintf(str, "In vkCmdResetQueryPool() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
- device_log_msg(cmdBuffer, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
loader_platform_thread_unlock_mutex(&globalLock);
- device_dispatch_table(cmdBuffer)->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+ get_dispatch_table(mem_tracker_device_table_map, cmdBuffer)->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
}
VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
@@ -2072,14 +2104,27 @@
void* pUserData,
VkDbgMsgCallback* pMsgCallback)
{
- return layer_create_msg_callback(instance, instance_dispatch_table(instance), msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ VkLayerInstanceDispatchTable *pTable = get_dispatch_table(mem_tracker_instance_table_map, instance);
+ VkResult res = pTable->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ if (res == VK_SUCCESS) {
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+
+ res = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+ }
+ return res;
}
VK_LAYER_EXPORT VkResult VKAPI vkDbgDestroyMsgCallback(
VkInstance instance,
VkDbgMsgCallback msgCallback)
{
- return layer_destroy_msg_callback(instance, instance_dispatch_table(instance), msgCallback);
+ VkLayerInstanceDispatchTable *pTable = get_dispatch_table(mem_tracker_instance_table_map, instance);
+ VkResult res = pTable->DbgDestroyMsgCallback(instance, msgCallback);
+
+ layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_destroy_msg_callback(my_data->report_data, msgCallback);
+
+ return res;
}
VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapChainWSI(
@@ -2087,7 +2132,7 @@
const VkSwapChainCreateInfoWSI *pCreateInfo,
VkSwapChainWSI *pSwapChain)
{
- VkResult result = device_dispatch_table(device)->CreateSwapChainWSI(device, pCreateInfo, pSwapChain);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateSwapChainWSI(device, pCreateInfo, pSwapChain);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
@@ -2122,7 +2167,7 @@
loader_platform_thread_unlock_mutex(&globalLock);
- return device_dispatch_table(swapChain)->DestroySwapChainWSI(swapChain);
+ return get_dispatch_table(mem_tracker_device_table_map, swapChain)->DestroySwapChainWSI(swapChain);
}
VK_LAYER_EXPORT VkResult VKAPI vkGetSwapChainInfoWSI(
@@ -2131,7 +2176,7 @@
size_t *pDataSize,
void *pData)
{
- VkResult result = device_dispatch_table(swapChain)->GetSwapChainInfoWSI(swapChain, infoType, pDataSize, pData);
+ VkResult result = get_dispatch_table(mem_tracker_device_table_map, swapChain)->GetSwapChainInfoWSI(swapChain, infoType, pDataSize, pData);
if (infoType == VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI && result == VK_SUCCESS) {
const size_t count = *pDataSize / sizeof(VkSwapChainImageInfoWSI);
@@ -2150,7 +2195,7 @@
if (VK_FALSE == set_object_binding(it->image, it->memory)) {
char str[1024];
sprintf(str, "In vkGetSwapChainInfoWSI(), unable to set image %p binding to mem obj %p", (void*)it->image, (void*)it->memory);
- device_log_msg(swapChain, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, it->image, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+ device_log_msg(mdd(swapChain), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, it->image, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
}
}
}
@@ -2161,7 +2206,7 @@
if (mismatch) {
char str[1024];
sprintf(str, "vkGetSwapChainInfoWSI(%p, VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI) returned mismatching data", swapChain);
- device_log_msg(swapChain, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_SWAP_CHAIN_WSI, (VkObject) swapChain, 0, MEMTRACK_NONE, "SWAP_CHAIN", str);
+ device_log_msg(mdd(swapChain), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_SWAP_CHAIN_WSI, (VkObject) swapChain, 0, MEMTRACK_NONE, "SWAP_CHAIN", str);
}
}
}
@@ -2183,7 +2228,7 @@
/* loader uses this to force layer initialization; device object is wrapped */
if (!strcmp(funcName, "vkGetDeviceProcAddr")) {
- initDeviceTable((const VkBaseLayerObject *) dev);
+ initDeviceTable(mem_tracker_device_table_map, (const VkBaseLayerObject *) dev);
return (void *) vkGetDeviceProcAddr;
}
if (!strcmp(funcName, "vkDestroyDevice"))
@@ -2320,9 +2365,9 @@
return (void*) vkGetSwapChainInfoWSI;
{
- if (device_dispatch_table(dev)->GetDeviceProcAddr == NULL)
+ if (get_dispatch_table(mem_tracker_device_table_map, dev)->GetDeviceProcAddr == NULL)
return NULL;
- return device_dispatch_table(dev)->GetDeviceProcAddr(dev, funcName);
+ return get_dispatch_table(mem_tracker_device_table_map, dev)->GetDeviceProcAddr(dev, funcName);
}
}
@@ -2339,7 +2384,7 @@
/* loader uses this to force layer initialization; instance object is wrapped */
if (!strcmp(funcName, "vkGetInstanceProcAddr")) {
- initInstanceTable((const VkBaseLayerObject *) instance);
+ initInstanceTable(mem_tracker_instance_table_map, (const VkBaseLayerObject *) instance);
return (void *) vkGetInstanceProcAddr;
}
@@ -2350,13 +2395,14 @@
if (!strcmp(funcName, "vkCreateDevice"))
return (void*) vkCreateDevice;
- fptr = debug_report_get_instance_proc_addr(instance, funcName);
+ layer_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;
{
- if (instance_dispatch_table(instance)->GetInstanceProcAddr == NULL)
+ if (get_dispatch_table(mem_tracker_instance_table_map, instance)->GetInstanceProcAddr == NULL)
return NULL;
- return instance_dispatch_table(instance)->GetInstanceProcAddr(instance, funcName);
+ return get_dispatch_table(mem_tracker_instance_table_map, instance)->GetInstanceProcAddr(instance, funcName);
}
}