blob: b6a839d320e81b008d2db05193f24e27675e67ec [file] [log] [blame]
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001/*
Mark Lobodzinski283a4c22015-03-24 16:29:24 -05002 * Vulkan
Tobin Ehlis791a49c2014-11-10 12:29:12 -07003 *
Mark Lobodzinski283a4c22015-03-24 16:29:24 -05004 * Copyright (C) 2015 LunarG, Inc.
Tobin Ehlis791a49c2014-11-10 12:29:12 -07005 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
Mark Lobodzinski283a4c22015-03-24 16:29:24 -050017* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
Tobin Ehlis791a49c2014-11-10 12:29:12 -070018 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
24
Mark Lobodzinski4aad3642015-03-17 10:53:12 -050025#include <inttypes.h>
Tobin Ehlis791a49c2014-11-10 12:29:12 -070026#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
29#include <assert.h>
Mark Lobodzinski283a4c22015-03-24 16:29:24 -050030#include <list>
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -050031#include <map>
Mike Stroyan53430332015-05-19 15:16:08 -060032#include <unordered_map>
Chia-I Wu5b66aa52015-04-16 22:02:10 +080033#include <vector>
Mark Lobodzinski283a4c22015-03-24 16:29:24 -050034using namespace std;
35
Ian Elliott81ac44c2015-01-13 17:52:38 -070036#include "loader_platform.h"
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -060037#include "vk_dispatch_table_helper.h"
38#include "vk_struct_string_helper_cpp.h"
Tobin Ehlis62086412014-11-19 16:19:28 -070039#include "mem_tracker.h"
Jon Ashburnf57ea372014-12-22 13:24:15 -070040#include "layers_config.h"
Ian Elliott20f06872015-02-12 17:08:34 -070041// The following is #included again to catch certain OS-specific functions
42// being used:
43#include "loader_platform.h"
Jon Ashburn5a7be202015-02-16 08:46:53 -070044#include "layers_msg.h"
Tobin Ehlis791a49c2014-11-10 12:29:12 -070045
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -050046static std::unordered_map<void *, VkLayerDispatchTable *> tableMap;
47static std::unordered_map<void *, VkLayerInstanceDispatchTable *> tableInstanceMap;
48
Ian Elliott81ac44c2015-01-13 17:52:38 -070049static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -050050
51static inline VkLayerDispatchTable *device_dispatch_table(VkObject object) {
52 VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) object;
53 VkLayerDispatchTable *pTable = tableMap[pDisp];
54 return pTable;
55}
56
57static inline VkLayerInstanceDispatchTable *instance_dispatch_table(VkObject object) {
58 VkLayerInstanceDispatchTable **ppDisp = (VkLayerInstanceDispatchTable **) object;
59 VkLayerInstanceDispatchTable *pInstanceTable = tableInstanceMap[*ppDisp];
60 return pInstanceTable;
61}
Jon Ashburnd9564002015-05-07 10:27:37 -060062
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -060063// TODO : This can be much smarter, using separate locks for separate global data
64static int globalLockInitialized = 0;
65static loader_platform_thread_mutex globalLock;
Jon Ashburnf57ea372014-12-22 13:24:15 -070066
Tobin Ehlis2836a7d2015-01-08 15:22:32 -070067#define MAX_BINDING 0xFFFFFFFF
Tobin Ehlis2836a7d2015-01-08 15:22:32 -070068
Mike Stroyan988caa42015-05-19 17:03:40 -060069unordered_map<VkCmdBuffer, MT_CB_INFO> cbMap;
70unordered_map<VkDeviceMemory, MT_MEM_OBJ_INFO> memObjMap;
71unordered_map<VkObject, MT_OBJ_INFO> objectMap;
72unordered_map<VkFence, MT_FENCE_INFO> fenceMap; // Map fence to fence info
73unordered_map<VkQueue, MT_QUEUE_INFO> queueMap;
Mike Stroyan53430332015-05-19 15:16:08 -060074unordered_map<VkSwapChainWSI, MT_SWAP_CHAIN_INFO*> swapChainMap;
Mark Lobodzinski283a4c22015-03-24 16:29:24 -050075
Mark Lobodzinski8ee96342015-04-02 20:49:09 -050076// TODO : Add per-device fence completion
Mark Lobodzinskia908b162015-04-21 15:33:04 -060077static uint64_t g_currentFenceId = 1;
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -060078static VkDevice globalDevice = NULL;
Mark Lobodzinski15427102015-02-18 16:38:17 -060079
Mark Lobodzinski85a83982015-04-02 08:52:53 -050080// Add new queue for this device to map container
Mark Lobodzinskic66c6712015-06-05 13:59:04 -050081static void add_queue_info(const VkQueue queue)
Mark Lobodzinski85a83982015-04-02 08:52:53 -050082{
Mike Stroyan988caa42015-05-19 17:03:40 -060083 MT_QUEUE_INFO* pInfo = &queueMap[queue];
Mark Lobodzinski8ee96342015-04-02 20:49:09 -050084 pInfo->lastRetiredId = 0;
85 pInfo->lastSubmittedId = 0;
Mark Lobodzinski85a83982015-04-02 08:52:53 -050086}
87
Mark Lobodzinskic66c6712015-06-05 13:59:04 -050088static void delete_queue_info_list(
Mark Lobodzinskia908b162015-04-21 15:33:04 -060089 void)
Mark Lobodzinski85a83982015-04-02 08:52:53 -050090{
91 // Process queue list, cleaning up each entry before deleting
Mark Lobodzinski85a83982015-04-02 08:52:53 -050092 queueMap.clear();
93}
94
Mark Lobodzinskic66c6712015-06-05 13:59:04 -050095static void add_swap_chain_info(
Mark Lobodzinskia908b162015-04-21 15:33:04 -060096 const VkSwapChainWSI swapChain)
Chia-I Wu5b66aa52015-04-16 22:02:10 +080097{
98 MT_SWAP_CHAIN_INFO* pInfo = new MT_SWAP_CHAIN_INFO;
99 swapChainMap[swapChain] = pInfo;
100}
101
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500102// Add new CBInfo for this cb to map container
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500103static void add_cmd_buf_info(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600104 const VkCmdBuffer cb)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700105{
Mike Stroyan988caa42015-05-19 17:03:40 -0600106 cbMap[cb].cmdBuffer = cb;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700107}
108
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500109// Return ptr to Info in CB map, or NULL if not found
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500110static MT_CB_INFO* get_cmd_buf_info(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600111 const VkCmdBuffer cb)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700112{
Mike Stroyan988caa42015-05-19 17:03:40 -0600113 unordered_map<VkCmdBuffer, MT_CB_INFO>::iterator item = cbMap.find(cb);
Mike Stroyan53430332015-05-19 15:16:08 -0600114 if (item != cbMap.end()) {
Mike Stroyan988caa42015-05-19 17:03:40 -0600115 return &(*item).second;
Mike Stroyan53430332015-05-19 15:16:08 -0600116 } else {
117 return NULL;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600118 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700119}
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600120
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -0500121// Return object info for 'object' or return NULL if no info exists
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500122static MT_OBJ_INFO* get_object_info(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600123 const VkObject object)
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -0500124{
Mike Stroyan988caa42015-05-19 17:03:40 -0600125 unordered_map<VkObject, MT_OBJ_INFO>::iterator item = objectMap.find(object);
Mike Stroyan53430332015-05-19 15:16:08 -0600126 if (item != objectMap.end()) {
Mike Stroyan988caa42015-05-19 17:03:40 -0600127 return &(*item).second;
Mike Stroyan53430332015-05-19 15:16:08 -0600128 } else {
129 return NULL;
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -0500130 }
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -0500131}
132
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500133static MT_OBJ_INFO* add_object_info(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600134 VkObject object,
135 VkStructureType sType,
136 const void *pCreateInfo,
137 const int struct_size,
138 const char *name_prefix)
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -0500139{
Mike Stroyan988caa42015-05-19 17:03:40 -0600140 MT_OBJ_INFO* pInfo = &objectMap[object];
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -0500141 memset(pInfo, 0, sizeof(MT_OBJ_INFO));
142 memcpy(&pInfo->create_info, pCreateInfo, struct_size);
143 sprintf(pInfo->object_name, "%s_%p", name_prefix, object);
144
145 pInfo->object = object;
146 pInfo->ref_count = 1;
147 pInfo->sType = sType;
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -0500148
149 return pInfo;
150}
151
Mark Lobodzinski4aad3642015-03-17 10:53:12 -0500152// Add a fence, creating one if necessary to our list of fences/fenceIds
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500153static uint64_t add_fence_info(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600154 VkFence fence,
155 VkQueue queue)
Mark Lobodzinski4aad3642015-03-17 10:53:12 -0500156{
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500157 // Create fence object
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500158 uint64_t fenceId = g_currentFenceId++;
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -0500159 // If no fence, create an internal fence to track the submissions
Mike Stroyan53430332015-05-19 15:16:08 -0600160 if (fence != NULL) {
Mike Stroyan988caa42015-05-19 17:03:40 -0600161 fenceMap[fence].fenceId = fenceId;
162 fenceMap[fence].queue = queue;
Mark Lobodzinski56945182015-04-09 13:46:09 -0500163 // Validate that fence is in UNSIGNALED state
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500164 MT_OBJ_INFO* pObjectInfo = get_object_info(fence);
Mark Lobodzinski56945182015-04-09 13:46:09 -0500165 if (pObjectInfo != NULL) {
Tobin Ehlisf29da382015-04-15 07:46:12 -0600166 if (pObjectInfo->create_info.fence_create_info.flags & VK_FENCE_CREATE_SIGNALED_BIT) {
Mark Lobodzinski56945182015-04-09 13:46:09 -0500167 char str[1024];
168 sprintf(str, "Fence %p submitted in SIGNALED state. Fences must be reset before being submitted", fence);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600169 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
Mark Lobodzinski56945182015-04-09 13:46:09 -0500170 }
171 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700172 }
Mike Stroyan53430332015-05-19 15:16:08 -0600173 // Update most recently submitted fence and fenceId for Queue
Mike Stroyan988caa42015-05-19 17:03:40 -0600174 queueMap[queue].lastSubmittedId = fenceId;
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500175 return fenceId;
Mark Lobodzinski4aad3642015-03-17 10:53:12 -0500176}
177
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500178// Remove a fenceInfo from our list of fences/fenceIds
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500179static void delete_fence_info(
Mike Stroyan53430332015-05-19 15:16:08 -0600180 VkFence fence)
Mark Lobodzinski4aad3642015-03-17 10:53:12 -0500181{
Mike Stroyan988caa42015-05-19 17:03:40 -0600182 fenceMap.erase(fence);
Mark Lobodzinski4aad3642015-03-17 10:53:12 -0500183}
184
Mike Stroyan53430332015-05-19 15:16:08 -0600185// Record information when a fence is known to be signalled
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500186static void update_fence_tracking(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600187 VkFence fence)
Mark Lobodzinski4aad3642015-03-17 10:53:12 -0500188{
Mike Stroyan988caa42015-05-19 17:03:40 -0600189 unordered_map<VkFence, MT_FENCE_INFO>::iterator fence_item = fenceMap.find(fence);
Mike Stroyan53430332015-05-19 15:16:08 -0600190 if (fence_item != fenceMap.end()) {
Mike Stroyan988caa42015-05-19 17:03:40 -0600191 MT_FENCE_INFO *pCurFenceInfo = &(*fence_item).second;
Mike Stroyan53430332015-05-19 15:16:08 -0600192 VkQueue queue = pCurFenceInfo->queue;
Mike Stroyan988caa42015-05-19 17:03:40 -0600193 unordered_map<VkQueue, MT_QUEUE_INFO>::iterator queue_item = queueMap.find(queue);
Mike Stroyan53430332015-05-19 15:16:08 -0600194 if (queue_item != queueMap.end()) {
Mike Stroyan988caa42015-05-19 17:03:40 -0600195 MT_QUEUE_INFO *pQueueInfo = &(*queue_item).second;
Mike Stroyan53430332015-05-19 15:16:08 -0600196 if (pQueueInfo->lastRetiredId < pCurFenceInfo->fenceId) {
197 pQueueInfo->lastRetiredId = pCurFenceInfo->fenceId;
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -0500198 }
Mark Lobodzinski4aad3642015-03-17 10:53:12 -0500199 }
200 }
Mark Lobodzinski4aad3642015-03-17 10:53:12 -0500201
Mike Stroyan53430332015-05-19 15:16:08 -0600202 // Update fence state in fenceCreateInfo structure
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500203 MT_OBJ_INFO* pObjectInfo = get_object_info(fence);
Mike Stroyan53430332015-05-19 15:16:08 -0600204 if (pObjectInfo != NULL) {
205 pObjectInfo->create_info.fence_create_info.flags =
206 static_cast<VkFenceCreateFlags>(
207 pObjectInfo->create_info.fence_create_info.flags | VK_FENCE_CREATE_SIGNALED_BIT);
Mark Lobodzinski4aad3642015-03-17 10:53:12 -0500208 }
Mark Lobodzinski4aad3642015-03-17 10:53:12 -0500209}
210
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500211// Helper routine that updates the fence list for a specific queue to all-retired
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500212static void retire_queue_fences(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600213 VkQueue queue)
Mark Lobodzinski4aad3642015-03-17 10:53:12 -0500214{
Mike Stroyan988caa42015-05-19 17:03:40 -0600215 MT_QUEUE_INFO *pQueueInfo = &queueMap[queue];
216 // Set queue's lastRetired to lastSubmitted indicating all fences completed
Courtney Goeltzenleuchterc6b048f2015-04-14 00:01:21 -0600217 pQueueInfo->lastRetiredId = pQueueInfo->lastSubmittedId;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700218}
219
Mike Stroyan988caa42015-05-19 17:03:40 -0600220// Helper routine that updates all queues to all-retired
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500221static void retire_device_fences(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600222 VkDevice device)
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500223{
224 // Process each queue for device
Courtney Goeltzenleuchterc6b048f2015-04-14 00:01:21 -0600225 // TODO: Add multiple device support
Mike Stroyan988caa42015-05-19 17:03:40 -0600226 for (unordered_map<VkQueue, MT_QUEUE_INFO>::iterator ii=queueMap.begin(); ii!=queueMap.end(); ++ii) {
227 // Set queue's lastRetired to lastSubmitted indicating all fences completed
228 MT_QUEUE_INFO *pQueueInfo = &(*ii).second;
229 pQueueInfo->lastRetiredId = pQueueInfo->lastSubmittedId;
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500230 }
231}
232
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500233// Return ptr to info in map container containing mem, or NULL if not found
Tobin Ehlis77b3abb2015-03-04 08:38:22 -0700234// Calls to this function should be wrapped in mutex
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500235static MT_MEM_OBJ_INFO* get_mem_obj_info(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600236 const VkDeviceMemory mem)
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700237{
Mike Stroyan988caa42015-05-19 17:03:40 -0600238 unordered_map<VkDeviceMemory, MT_MEM_OBJ_INFO>::iterator item = memObjMap.find(mem);
Mike Stroyan53430332015-05-19 15:16:08 -0600239 if (item != memObjMap.end()) {
Mike Stroyan988caa42015-05-19 17:03:40 -0600240 return &(*item).second;
Mike Stroyan53430332015-05-19 15:16:08 -0600241 } else {
242 return NULL;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600243 }
Tobin Ehlis2836a7d2015-01-08 15:22:32 -0700244}
245
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500246static void add_mem_obj_info(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600247 const VkDeviceMemory mem,
248 const VkMemoryAllocInfo *pAllocInfo)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700249{
Mike Stroyan988caa42015-05-19 17:03:40 -0600250 memObjMap[mem].refCount = 0;
Chia-I Wu5b66aa52015-04-16 22:02:10 +0800251 if (pAllocInfo) { // MEM alloc created by vkCreateSwapChainWSI() doesn't have alloc info struct
Mike Stroyan988caa42015-05-19 17:03:40 -0600252 memcpy(&memObjMap[mem].allocInfo, pAllocInfo, sizeof(VkMemoryAllocInfo));
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500253 // TODO: Update for real hardware, actually process allocation info structures
Mike Stroyan988caa42015-05-19 17:03:40 -0600254 memObjMap[mem].allocInfo.pNext = NULL;
255 } else {
256 memset(&memObjMap[mem].allocInfo, 0, sizeof(VkMemoryAllocInfo));
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700257 }
Mike Stroyan988caa42015-05-19 17:03:40 -0600258 memObjMap[mem].mem = mem;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700259}
260
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500261// Find CB Info and add mem reference to list container
262// Find Mem Obj Info and add CB reference to list container
263static bool32_t update_cmd_buf_and_mem_references(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600264 const VkCmdBuffer cb,
265 const VkDeviceMemory mem)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700266{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600267 bool32_t result = VK_TRUE;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700268 // First update CB binding in MemObj mini CB list
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500269 MT_MEM_OBJ_INFO* pMemInfo = get_mem_obj_info(mem);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500270 if (!pMemInfo) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700271 char str[1024];
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600272 sprintf(str, "Trying to bind mem obj %p to CB %p but no info for that mem obj.\n "
273 "Was it correctly allocated? Did it already get freed?", mem, cb);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600274 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600275 result = VK_FALSE;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600276 } else {
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500277 // Search for cmd buffer object in memory object's binding list
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600278 bool32_t found = VK_FALSE;
David Pinedof5997ab2015-04-27 16:36:17 -0600279 if (pMemInfo->pCmdBufferBindings.size() > 0) {
280 for (list<VkCmdBuffer>::iterator it = pMemInfo->pCmdBufferBindings.begin(); it != pMemInfo->pCmdBufferBindings.end(); ++it) {
281 if ((*it) == cb) {
282 found = VK_TRUE;
283 break;
284 }
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500285 }
286 }
287 // If not present, add to list
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600288 if (found == VK_FALSE) {
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500289 pMemInfo->pCmdBufferBindings.push_front(cb);
290 pMemInfo->refCount++;
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500291 }
292
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500293 // Now update CBInfo's Mem reference list
294 MT_CB_INFO* pCBInfo = get_cmd_buf_info(cb);
295 // TODO: keep track of all destroyed CBs so we know if this is a stale or simply invalid object
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500296 if (!pCBInfo) {
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500297 char str[1024];
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500298 sprintf(str, "Trying to bind mem obj %p to CB %p but no info for that CB. Was CB incorrectly destroyed?", mem, cb);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600299 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600300 result = VK_FALSE;
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500301 } else {
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500302 // Search for memory object in cmd buffer's reference list
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600303 bool32_t found = VK_FALSE;
David Pinedof5997ab2015-04-27 16:36:17 -0600304 if (pCBInfo->pMemObjList.size() > 0) {
305 for (list<VkDeviceMemory>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
306 if ((*it) == mem) {
307 found = VK_TRUE;
308 break;
309 }
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500310 }
311 }
312 // If not present, add to list
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600313 if (found == VK_FALSE) {
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500314 pCBInfo->pMemObjList.push_front(mem);
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600315 }
316 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700317 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600318 return result;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700319}
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600320
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700321// Clear the CB Binding for mem
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500322// Calls to this function should be wrapped in mutex
323static void remove_cmd_buf_and_mem_reference(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600324 const VkCmdBuffer cb,
325 const VkDeviceMemory mem)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700326{
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500327 MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem);
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500328 // TODO : Having this check is not ideal, really if memInfo was deleted,
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500329 // its CB bindings should be cleared and then clear_cmd_buf_and_mem_references wouldn't call
Tobin Ehlis77b3abb2015-03-04 08:38:22 -0700330 // us here with stale mem objs
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500331 if (pInfo) {
332 pInfo->pCmdBufferBindings.remove(cb);
333 pInfo->refCount--;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700334 }
335}
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600336
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700337// Free bindings related to CB
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500338static bool32_t clear_cmd_buf_and_mem_references(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600339 const VkCmdBuffer cb)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700340{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600341 bool32_t result = VK_TRUE;
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500342 MT_CB_INFO* pCBInfo = get_cmd_buf_info(cb);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500343 if (!pCBInfo) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700344 char str[1024];
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500345 sprintf(str, "Unable to find global CB info %p for deletion", cb);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600346 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600347 result = VK_FALSE;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600348 } else {
Courtney Goeltzenleuchtera43cbbf2015-04-29 10:51:48 -0600349 if (pCBInfo->pMemObjList.size() > 0) {
350 list<VkDeviceMemory> mem_obj_list = pCBInfo->pMemObjList;
351 for (list<VkDeviceMemory>::iterator it=mem_obj_list.begin(); it!=mem_obj_list.end(); ++it) {
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500352 remove_cmd_buf_and_mem_reference(cb, (*it));
David Pinedof5997ab2015-04-27 16:36:17 -0600353 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600354 }
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500355 pCBInfo->pMemObjList.clear();
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700356 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600357 return result;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700358}
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600359
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500360// Delete CBInfo from list along with all of it's mini MemObjInfo
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500361// and also clear mem references to CB
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500362static bool32_t delete_cmd_buf_info(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600363 const VkCmdBuffer cb)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700364{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600365 bool32_t result = VK_TRUE;
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500366 result = clear_cmd_buf_and_mem_references(cb);
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500367 // Delete the CBInfo info
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600368 if (result == VK_TRUE) {
Mike Stroyan988caa42015-05-19 17:03:40 -0600369 cbMap.erase(cb);
Ian Elliott81ac44c2015-01-13 17:52:38 -0700370 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600371 return result;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700372}
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600373
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700374// Delete the entire CB list
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500375static bool32_t delete_cmd_buf_info_list(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600376 void)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700377{
Mike Stroyan988caa42015-05-19 17:03:40 -0600378 for (unordered_map<VkCmdBuffer, MT_CB_INFO>::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) {
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500379 clear_cmd_buf_and_mem_references((*ii).first);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700380 }
Mike Stroyan988caa42015-05-19 17:03:40 -0600381 cbMap.clear();
382 return VK_TRUE;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700383}
384
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500385// For given MemObjInfo, report Obj & CB bindings
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600386static void reportMemReferencesAndCleanUp(
387 MT_MEM_OBJ_INFO* pMemObjInfo)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700388{
Tony Barboura938abb2015-04-22 11:36:22 -0600389 size_t cmdBufRefCount = pMemObjInfo->pCmdBufferBindings.size();
390 size_t objRefCount = pMemObjInfo->pObjBindings.size();
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500391
Mark Lobodzinskicf26e072015-04-16 11:44:05 -0500392 if ((pMemObjInfo->pCmdBufferBindings.size() + pMemObjInfo->pObjBindings.size()) != 0) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700393 char str[1024];
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600394 sprintf(str, "Attempting to free memory object %p which still contains %lu references",
395 pMemObjInfo->mem, (cmdBufRefCount + objRefCount));
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600396 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, pMemObjInfo->mem, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700397 }
Mark Lobodzinskicf26e072015-04-16 11:44:05 -0500398
David Pinedof5997ab2015-04-27 16:36:17 -0600399 if (cmdBufRefCount > 0 && pMemObjInfo->pCmdBufferBindings.size() > 0) {
Mark Lobodzinskicf26e072015-04-16 11:44:05 -0500400 for (list<VkCmdBuffer>::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) {
401 char str[1024];
402 sprintf(str, "Command Buffer %p still has a reference to mem obj %p", (*it), pMemObjInfo->mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600403 layerCbMsg(VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (*it), 0, MEMTRACK_NONE, "MEM", str);
Mark Lobodzinskicf26e072015-04-16 11:44:05 -0500404 }
405 // Clear the list of hanging references
406 pMemObjInfo->pCmdBufferBindings.clear();
407 }
408
David Pinedof5997ab2015-04-27 16:36:17 -0600409 if (objRefCount > 0 && pMemObjInfo->pObjBindings.size() > 0) {
Mark Lobodzinskicf26e072015-04-16 11:44:05 -0500410 for (list<VkObject>::const_iterator it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) {
411 char str[1024];
412 sprintf(str, "VK Object %p still has a reference to mem obj %p", (*it), pMemObjInfo->mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600413 /* TODO: Would be nice to return the actual object type */
414 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, (*it), 0, MEMTRACK_NONE, "MEM", str);
Mark Lobodzinskicf26e072015-04-16 11:44:05 -0500415 }
416 // Clear the list of hanging references
417 pMemObjInfo->pObjBindings.clear();
418 }
Mark Lobodzinski5f25be42015-05-14 15:08:13 -0500419
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700420}
421
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600422static void deleteMemObjInfo(
423 VkDeviceMemory mem)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700424{
Mike Stroyan988caa42015-05-19 17:03:40 -0600425 unordered_map<VkDeviceMemory, MT_MEM_OBJ_INFO>::iterator item = memObjMap.find(mem);
Mike Stroyan53430332015-05-19 15:16:08 -0600426 if (item != memObjMap.end()) {
Mike Stroyan53430332015-05-19 15:16:08 -0600427 memObjMap.erase(item);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700428 }
Mark Lobodzinskicf26e072015-04-16 11:44:05 -0500429 else {
430 char str[1024];
431 sprintf(str, "Request to delete memory object %p not present in memory Object Map", mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600432 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Mark Lobodzinskicf26e072015-04-16 11:44:05 -0500433 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700434}
Mark Lobodzinski4aad3642015-03-17 10:53:12 -0500435
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700436// Check if fence for given CB is completed
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600437static bool32_t checkCBCompleted(
438 const VkCmdBuffer cb)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700439{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600440 bool32_t result = VK_TRUE;
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500441 MT_CB_INFO* pCBInfo = get_cmd_buf_info(cb);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500442 if (!pCBInfo) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700443 char str[1024];
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500444 sprintf(str, "Unable to find global CB info %p to check for completion", cb);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600445 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_INVALID_CB, "MEM", str);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600446 result = VK_FALSE;
Mike Stroyan53430332015-05-19 15:16:08 -0600447 } else if (pCBInfo->lastSubmittedQueue != NULL) {
448 VkQueue queue = pCBInfo->lastSubmittedQueue;
Mike Stroyan988caa42015-05-19 17:03:40 -0600449 MT_QUEUE_INFO *pQueueInfo = &queueMap[queue];
Mike Stroyan53430332015-05-19 15:16:08 -0600450 if (pCBInfo->fenceId > pQueueInfo->lastRetiredId) {
Courtney Goeltzenleuchterc6b048f2015-04-14 00:01:21 -0600451 char str[1024];
Mike Stroyan53430332015-05-19 15:16:08 -0600452 sprintf(str, "fence %p for CB %p has not been checked for completion",
453 (void*)pCBInfo->lastSubmittedFence, cb);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600454 layerCbMsg(VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cb, 0, MEMTRACK_NONE, "MEM", str);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600455 result = VK_FALSE;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600456 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700457 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600458 return result;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700459}
460
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600461static bool32_t freeMemObjInfo(
462 VkDeviceMemory mem,
463 bool internal)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700464{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600465 bool32_t result = VK_TRUE;
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500466 // Parse global list to find info w/ mem
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500467 MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500468 if (!pInfo) {
Tobin Ehlis62086412014-11-19 16:19:28 -0700469 char str[1024];
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600470 sprintf(str, "Couldn't find mem info object for %p\n Was %p never allocated or previously freed?",
471 (void*)mem, (void*)mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600472 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600473 result = VK_FALSE;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600474 } else {
Courtney Goeltzenleuchterc4804862015-03-26 16:15:39 -0600475 if (pInfo->allocInfo.allocationSize == 0 && !internal) {
Mark Lobodzinskidaa1d432015-02-18 18:06:24 -0600476 char str[1024];
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600477 sprintf(str, "Attempting to free memory associated with a Persistent Image, %p, "
478 "this should not be explicitly freed\n", (void*)mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600479 layerCbMsg(VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600480 result = VK_FALSE;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600481 } else {
482 // Clear any CB bindings for completed CBs
483 // TODO : Is there a better place to do this?
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500484
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600485 list<VkCmdBuffer>::iterator it = pInfo->pCmdBufferBindings.begin();
486 list<VkCmdBuffer>::iterator temp;
David Pinedof5997ab2015-04-27 16:36:17 -0600487 while (pInfo->pCmdBufferBindings.size() > 0 && it != pInfo->pCmdBufferBindings.end()) {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600488 if (VK_TRUE == checkCBCompleted(*it)) {
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500489 temp = it;
490 ++temp;
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500491 clear_cmd_buf_and_mem_references(*it);
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500492 it = temp;
493 } else {
494 ++it;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600495 }
496 }
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500497
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600498 // Now verify that no references to this mem obj remain
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500499 if (0 != pInfo->refCount) {
Mark Lobodzinskicf26e072015-04-16 11:44:05 -0500500 reportMemReferencesAndCleanUp(pInfo);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600501 result = VK_FALSE;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600502 }
Courtney Goeltzenleuchterc6b048f2015-04-14 00:01:21 -0600503 // Delete mem obj info
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500504 deleteMemObjInfo(mem);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700505 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700506 }
507 return result;
508}
509
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700510// Remove object binding performs 3 tasks:
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500511// 1. Remove ObjectInfo from MemObjInfo list container of obj bindings & free it
512// 2. Decrement refCount for MemObjInfo
513// 3. Clear MemObjInfo ptr from ObjectInfo
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500514static bool32_t clear_object_binding(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600515 VkObject object)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700516{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600517 bool32_t result = VK_FALSE;
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500518 MT_OBJ_INFO* pObjInfo = get_object_info(object);
519 if (pObjInfo) {
David Pinedof5997ab2015-04-27 16:36:17 -0600520 if (!pObjInfo->pMemObjInfo || pObjInfo->pMemObjInfo->pObjBindings.size() <= 0) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600521 char str[1024];
522 sprintf(str, "Attempting to clear mem binding on obj %p but it has no binding.", (void*)object);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600523 layerCbMsg(VK_DBG_REPORT_WARN_BIT, (VkObjectType) 0, object, 0, MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS, "MEM", str);
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600524 } else {
Mark Lobodzinskicf26e072015-04-16 11:44:05 -0500525 // 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
526 // and set the objects memory binding pointer to NULL.
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600527 for (list<VkObject>::iterator it = pObjInfo->pMemObjInfo->pObjBindings.begin(); it != pObjInfo->pMemObjInfo->pObjBindings.end(); ++it) {
Mark Lobodzinskicf26e072015-04-16 11:44:05 -0500528 if ((*it) == object) {
529 pObjInfo->pMemObjInfo->refCount--;
530 pObjInfo->pMemObjInfo->pObjBindings.erase(it);
531 pObjInfo->pMemObjInfo = NULL;
532 result = VK_TRUE;
533 break;
534 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600535 }
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600536 if (result == VK_FALSE) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600537 char str[1024];
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500538 sprintf(str, "While trying to clear mem binding for object %p, unable to find that object referenced by mem obj %p",
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500539 object, pObjInfo->pMemObjInfo->mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600540 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600541 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700542 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700543 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600544 return result;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700545}
546
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500547// For NULL mem case, output warning
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500548// Make sure given object is in global object map
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500549// IF a previous binding existed, output validation error
550// Otherwise, add reference from objectInfo to memoryInfo
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500551// Add reference off of objInfo
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600552// Return VK_TRUE if addition is successful, VK_FALSE otherwise
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500553static bool32_t set_object_binding(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600554 VkObject object,
555 VkDeviceMemory mem)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700556{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600557 bool32_t result = VK_FALSE;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700558 // Handle NULL case separately, just clear previous binding & decrement reference
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600559 if (mem == VK_NULL_HANDLE) {
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500560 char str[1024];
561 sprintf(str, "Attempting to Bind Obj(%p) to NULL", (void*)object);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600562 layerCbMsg(VK_DBG_REPORT_WARN_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500563 return VK_TRUE;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600564 } else {
565 char str[1024];
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500566 MT_OBJ_INFO* pObjInfo = get_object_info(object);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500567 if (!pObjInfo) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600568 sprintf(str, "Attempting to update Binding of Obj(%p) that's not in global list()", (void*)object);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600569 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600570 return VK_FALSE;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600571 }
572 // non-null case so should have real mem obj
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500573 MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem);
574 if (!pInfo) {
575 sprintf(str, "While trying to bind mem for obj %p, couldn't find info for mem obj %p", (void*)object, (void*)mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600576 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500577 return VK_FALSE;
578 } else {
579 if (pObjInfo->pMemObjInfo != NULL) {
580 sprintf(str, "Attempting to bind memory (%p) to object (%p) which has already been bound to mem object %p",
581 (void*)mem, (void*)object, (void*)pObjInfo->pMemObjInfo->mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600582 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_REBIND_OBJECT, "MEM", str);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500583 return VK_FALSE;
584 }
585 else {
586 pInfo->pObjBindings.push_front(object);
587 pInfo->refCount++;
588
589 // For image objects, make sure default memory state is correctly set
590 // TODO : What's the best/correct way to handle this?
591 if (VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO == pObjInfo->sType) {
592 if (pObjInfo->create_info.image_create_info.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
593 VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)) {
594 // TODO:: More memory state transition stuff.
595 }
596 }
597 pObjInfo->pMemObjInfo = pInfo;
598 }
599 }
600 }
601 return VK_TRUE;
602}
603
604// For NULL mem case, clear any previous binding Else...
605// Make sure given object is in global object map
606// IF a previous binding existed, update binding
607// Add reference from objectInfo to memoryInfo
608// Add reference off of objInfo
609// Return VK_TRUE if addition is successful, VK_FALSE otherwise
610static bool32_t set_sparse_buffer_binding(
611 VkObject object,
612 VkDeviceMemory mem)
613{
614 bool32_t result = VK_FALSE;
615 // Handle NULL case separately, just clear previous binding & decrement reference
616 if (mem == VK_NULL_HANDLE) {
617 clear_object_binding(object);
618 return VK_TRUE;
619 } else {
620 char str[1024];
621 MT_OBJ_INFO* pObjInfo = get_object_info(object);
622 if (!pObjInfo) {
623 sprintf(str, "Attempting to update Binding of Obj(%p) that's not in global list()", (void*)object);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600624 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500625 return VK_FALSE;
626 }
627 // non-null case so should have real mem obj
628 MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem);
Courtney Goeltzenleuchtera43cbbf2015-04-29 10:51:48 -0600629 if (!pInfo) {
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500630 sprintf(str, "While trying to bind mem for obj %p, couldn't find info for mem obj %p", (void*)object, (void*)mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600631 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", str);
Mark Lobodzinski5f25be42015-05-14 15:08:13 -0500632 return VK_FALSE;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600633 } else {
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500634 // Search for object in memory object's binding list
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600635 bool32_t found = VK_FALSE;
Courtney Goeltzenleuchtera43cbbf2015-04-29 10:51:48 -0600636 if (pInfo->pObjBindings.size() > 0) {
637 for (list<VkObject>::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) {
638 if ((*it) == object) {
639 found = VK_TRUE;
640 break;
641 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600642 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600643 }
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500644 // If not present, add to list
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600645 if (found == VK_FALSE) {
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500646 pInfo->pObjBindings.push_front(object);
647 pInfo->refCount++;
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500648 }
649
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500650 if (pObjInfo->pMemObjInfo) {
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500651 clear_object_binding(object); // Need to clear the previous object binding before setting new binding
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500652 sprintf(str, "Updating memory binding for object %p from mem obj %p to %p", object, pObjInfo->pMemObjInfo->mem, mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600653 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, object, 0, MEMTRACK_NONE, "MEM", str);
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500654 }
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500655 pObjInfo->pMemObjInfo = pInfo;
Tobin Ehlis6aa77422015-01-07 17:49:29 -0700656 }
657 }
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600658 return VK_TRUE;
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700659}
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600660
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700661// Print details of global Obj tracking list
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500662static void print_object_list(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600663 void)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700664{
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500665 MT_OBJ_INFO* pInfo = NULL;
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500666 char str[1024];
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500667 sprintf(str, "Details of Object list of size %lu elements", objectMap.size());
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600668 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
David Pinedof5997ab2015-04-27 16:36:17 -0600669 if (objectMap.size() <= 0)
670 return;
Mike Stroyan988caa42015-05-19 17:03:40 -0600671 for (unordered_map<VkObject, MT_OBJ_INFO>::iterator ii=objectMap.begin(); ii!=objectMap.end(); ++ii) {
672 pInfo = &(*ii).second;
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500673 sprintf(str, " ObjInfo %p has object %p, pMemObjInfo %p", pInfo, pInfo->object, pInfo->pMemObjInfo);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600674 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, pInfo->object, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700675 }
676}
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600677
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700678// For given Object, get 'mem' obj that it's bound to or NULL if no binding
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500679static VkDeviceMemory get_mem_binding_from_object(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600680 const VkObject object)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700681{
Tony Barbour8205d902015-04-16 15:59:00 -0600682 VkDeviceMemory mem = NULL;
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500683 MT_OBJ_INFO* pObjInfo = get_object_info(object);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500684 if (pObjInfo) {
685 if (pObjInfo->pMemObjInfo) {
686 mem = pObjInfo->pMemObjInfo->mem;
Courtney Goeltzenleuchtera43cbbf2015-04-29 10:51:48 -0600687 } else {
Tobin Ehlis62086412014-11-19 16:19:28 -0700688 char str[1024];
689 sprintf(str, "Trying to get mem binding for object %p but object has no mem binding", (void*)object);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600690 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_MISSING_MEM_BINDINGS, "MEM", str);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500691 print_object_list();
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700692 }
Courtney Goeltzenleuchtera43cbbf2015-04-29 10:51:48 -0600693 } else {
Tobin Ehlis62086412014-11-19 16:19:28 -0700694 char str[1024];
695 sprintf(str, "Trying to get mem binding for object %p but no such object in global list", (void*)object);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600696 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500697 print_object_list();
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700698 }
699 return mem;
700}
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500701
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500702// Print details of MemObjInfo list
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500703static void print_mem_list(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600704 void)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700705{
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500706 MT_MEM_OBJ_INFO* pInfo = NULL;
Tobin Ehlis62086412014-11-19 16:19:28 -0700707 // Just printing each msg individually for now, may want to package these into single large print
708 char str[1024];
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500709 sprintf(str, "MEM INFO : Details of Memory Object list of size %lu elements", memObjMap.size());
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600710 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500711
David Pinedof5997ab2015-04-27 16:36:17 -0600712 if (memObjMap.size() <= 0)
713 return;
714
Mike Stroyan988caa42015-05-19 17:03:40 -0600715 for (unordered_map<VkDeviceMemory, MT_MEM_OBJ_INFO>::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) {
716 pInfo = &(*ii).second;
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500717
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500718 sprintf(str, " ===MemObjInfo at %p===", (void*)pInfo);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600719 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500720 sprintf(str, " Mem object: %p", (void*)pInfo->mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600721 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500722 sprintf(str, " Ref Count: %u", pInfo->refCount);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600723 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500724 if (0 != pInfo->allocInfo.allocationSize) {
Courtney Goeltzenleuchterddcb6192015-04-14 18:48:46 -0600725 string pAllocInfoMsg = vk_print_vkmemoryallocinfo(&pInfo->allocInfo, "{MEM}INFO : ");
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500726 sprintf(str, " Mem Alloc info:\n%s", pAllocInfoMsg.c_str());
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600727 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500728 } else {
Chia-I Wu5b66aa52015-04-16 22:02:10 +0800729 sprintf(str, " Mem Alloc info is NULL (alloc done by vkCreateSwapChainWSI())");
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600730 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500731 }
732
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600733 sprintf(str, " VK OBJECT Binding list of size %lu elements:", pInfo->pObjBindings.size());
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600734 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
David Pinedof5997ab2015-04-27 16:36:17 -0600735 if (pInfo->pObjBindings.size() > 0) {
736 for (list<VkObject>::iterator it = pInfo->pObjBindings.begin(); it != pInfo->pObjBindings.end(); ++it) {
737 sprintf(str, " VK OBJECT %p", (*it));
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600738 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
David Pinedof5997ab2015-04-27 16:36:17 -0600739 }
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500740 }
741
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600742 sprintf(str, " VK Command Buffer (CB) binding list of size %lu elements", pInfo->pCmdBufferBindings.size());
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600743 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
David Pinedof5997ab2015-04-27 16:36:17 -0600744 if (pInfo->pCmdBufferBindings.size() > 0)
745 {
746 for (list<VkCmdBuffer>::iterator it = pInfo->pCmdBufferBindings.begin(); it != pInfo->pCmdBufferBindings.end(); ++it) {
747 sprintf(str, " VK CB %p", (*it));
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600748 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
David Pinedof5997ab2015-04-27 16:36:17 -0600749 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700750 }
751 }
752}
753
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600754static void printCBList(
755 void)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700756{
Mike Stroyan53430332015-05-19 15:16:08 -0600757 char str[1024];
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500758 MT_CB_INFO* pCBInfo = NULL;
759 sprintf(str, "Details of CB list of size %lu elements", cbMap.size());
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600760 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500761
David Pinedof5997ab2015-04-27 16:36:17 -0600762 if (cbMap.size() <= 0)
763 return;
764
Mike Stroyan988caa42015-05-19 17:03:40 -0600765 for (unordered_map<VkCmdBuffer, MT_CB_INFO>::iterator ii=cbMap.begin(); ii!=cbMap.end(); ++ii) {
766 pCBInfo = &(*ii).second;
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500767
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500768 sprintf(str, " CB Info (%p) has CB %p, fenceId %" PRIx64", and fence %p",
769 (void*)pCBInfo, (void*)pCBInfo->cmdBuffer, pCBInfo->fenceId,
Mike Stroyan53430332015-05-19 15:16:08 -0600770 (void*)pCBInfo->lastSubmittedFence);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600771 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500772
David Pinedof5997ab2015-04-27 16:36:17 -0600773 if (pCBInfo->pMemObjList.size() <= 0)
774 continue;
Tony Barbour8205d902015-04-16 15:59:00 -0600775 for (list<VkDeviceMemory>::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) {
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500776 sprintf(str, " Mem obj %p", (*it));
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600777 layerCbMsg(VK_DBG_REPORT_INFO_BIT, (VkObjectType) 0, NULL, 0, MEMTRACK_NONE, "MEM", str);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700778 }
779 }
780}
781
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -0500782static VkLayerDispatchTable * initDeviceTable(const VkBaseLayerObject *devw)
783 {
784 VkLayerDispatchTable *pTable;
785
786 assert(devw);
787 VkLayerDispatchTable **ppDisp = (VkLayerDispatchTable **) (devw->baseObject);
788
789 std::unordered_map<void *, VkLayerDispatchTable *>::const_iterator it = tableMap.find((void *) *ppDisp);
790 if (it == tableMap.end())
791 {
792 pTable = new VkLayerDispatchTable;
793 tableMap[(void *) *ppDisp] = pTable;
794 } else
795 {
796 return it->second;
797 }
798
Jon Ashburn4f2575f2015-05-28 16:25:02 -0600799 layer_initialize_dispatch_table(pTable, devw);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -0500800
801 return pTable;
Jon Ashburnd9564002015-05-07 10:27:37 -0600802}
803
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -0500804
805static VkLayerInstanceDispatchTable * initInstanceTable(const VkBaseLayerObject *instw)
Jon Ashburnd9564002015-05-07 10:27:37 -0600806{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -0500807 VkLayerInstanceDispatchTable *pTable;
808 assert(instw);
809 VkLayerInstanceDispatchTable **ppDisp = (VkLayerInstanceDispatchTable **) instw->baseObject;
810
811 std::unordered_map<void *, VkLayerInstanceDispatchTable *>::const_iterator it = tableInstanceMap.find((void *) *ppDisp);
812 if (it == tableInstanceMap.end())
813 {
814 pTable = new VkLayerInstanceDispatchTable;
815 tableInstanceMap[(void *) *ppDisp] = pTable;
816 } else
817 {
818 return it->second;
819 }
820
Jon Ashburn4f2575f2015-05-28 16:25:02 -0600821 layer_init_instance_dispatch_table(pTable, instw);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -0500822
823 return pTable;
Jon Ashburnd9564002015-05-07 10:27:37 -0600824}
825
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600826static void initMemTracker(
827 void)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700828{
Jon Ashburnf57ea372014-12-22 13:24:15 -0700829 const char *strOpt;
830 // initialize MemTracker options
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600831 getLayerOptionEnum("MemTrackerReportLevel", (uint32_t *) &g_reportFlags);
Ian Elliott7d0b5d22015-03-06 13:50:05 -0700832 g_actionIsDefault = getLayerOptionEnum("MemTrackerDebugAction", (uint32_t *) &g_debugAction);
Tobin Ehlis5b7acaa2015-01-08 14:26:53 -0700833
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600834 if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
Jon Ashburnf57ea372014-12-22 13:24:15 -0700835 {
836 strOpt = getLayerOption("MemTrackerLogFilename");
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600837 if (strOpt) {
Jon Ashburnf57ea372014-12-22 13:24:15 -0700838 g_logFile = fopen(strOpt, "w");
Jon Ashburnf57ea372014-12-22 13:24:15 -0700839 }
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600840 if (g_logFile == NULL) {
Jon Ashburnf57ea372014-12-22 13:24:15 -0700841 g_logFile = stdout;
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600842 }
Jon Ashburnf57ea372014-12-22 13:24:15 -0700843 }
844
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600845 if (!globalLockInitialized)
846 {
847 // TODO/TBD: Need to delete this mutex sometime. How??? One
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600848 // suggestion is to call this during vkCreateInstance(), and then we
849 // can clean it up during vkDestroyInstance(). However, that requires
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600850 // that the layer have per-instance locks. We need to come back and
851 // address this soon.
852 loader_platform_thread_create_mutex(&globalLock);
853 globalLockInitialized = 1;
854 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700855}
856
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -0500857// hook DestroyInstance to remove tableInstanceMap entry
858VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance)
859{
860 VkLayerInstanceDispatchTable *pDisp = *(VkLayerInstanceDispatchTable **) instance;
861 VkResult res = instance_dispatch_table(instance)->DestroyInstance(instance);
862 tableInstanceMap.erase(pDisp);
863 return res;
864}
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600865
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -0600866VkResult VKAPI vkCreateInstance(
867 const VkInstanceCreateInfo* pCreateInfo,
868 VkInstance* pInstance)
869{
870 loader_platform_thread_once(&g_initOnce, initMemTracker);
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -0600871
872 VkResult result = instance_dispatch_table(*pInstance)->CreateInstance(pCreateInfo, pInstance);
873
874 if (result == VK_SUCCESS) {
875 enable_debug_report(pCreateInfo->extensionCount, pCreateInfo->pEnabledExtensions);
876 }
877 return result;
878}
879
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600880VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
881 VkPhysicalDevice gpu,
882 const VkDeviceCreateInfo *pCreateInfo,
883 VkDevice *pDevice)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700884{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -0500885 VkResult result = instance_dispatch_table(gpu)->CreateDevice(gpu, pCreateInfo, pDevice);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600886 if (result == VK_SUCCESS) {
887 // Save off device in case we need it to create Fences
888 globalDevice = *pDevice;
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600889 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700890 return result;
891}
892
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600893VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(
894 VkDevice device)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700895{
Tobin Ehlis62086412014-11-19 16:19:28 -0700896 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600897 sprintf(str, "Printing List details prior to vkDestroyDevice()");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600898 loader_platform_thread_lock_mutex(&globalLock);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600899 layerCbMsg(VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE, device, 0, MEMTRACK_NONE, "MEM", str);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500900 print_mem_list();
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500901 printCBList();
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500902 print_object_list();
903 if (VK_FALSE == delete_cmd_buf_info_list()) {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600904 sprintf(str, "Issue deleting global CB list in vkDestroyDevice()");
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600905 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, device, 0, MEMTRACK_INTERNAL_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -0700906 }
Tobin Ehlis22d03232014-11-25 18:01:12 -0700907 // Report any memory leaks
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -0500908 MT_MEM_OBJ_INFO* pInfo = NULL;
David Pinedof5997ab2015-04-27 16:36:17 -0600909 if (memObjMap.size() > 0) {
Mike Stroyan988caa42015-05-19 17:03:40 -0600910 for (unordered_map<VkDeviceMemory, MT_MEM_OBJ_INFO>::iterator ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) {
911 pInfo = &(*ii).second;
Mark Lobodzinski283a4c22015-03-24 16:29:24 -0500912
David Pinedof5997ab2015-04-27 16:36:17 -0600913 if (pInfo->allocInfo.allocationSize != 0) {
914 sprintf(str, "Mem Object %p has not been freed. You should clean up this memory by calling "
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600915 "vkFreeMemory(%p) prior to vkDestroyDevice().", pInfo->mem, pInfo->mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600916 layerCbMsg(VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, pInfo->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM", str);
David Pinedof5997ab2015-04-27 16:36:17 -0600917 }
Mark Lobodzinskidaa1d432015-02-18 18:06:24 -0600918 }
Tobin Ehlis22d03232014-11-25 18:01:12 -0700919 }
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500920
921 // Queues persist until device is destroyed
Mark Lobodzinskic66c6712015-06-05 13:59:04 -0500922 delete_queue_info_list();
Mark Lobodzinski85a83982015-04-02 08:52:53 -0500923
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -0600924 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -0500925
926 VkLayerDispatchTable *pDisp = *(VkLayerDispatchTable **) device;
927 VkLayerDispatchTable *pTable = tableMap[pDisp];
928 VkResult result = pTable->DestroyDevice(device);
929 tableMap.erase(pDisp);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700930 return result;
931}
932
Jon Ashburneb2728b2015-04-10 14:33:07 -0600933struct extProps {
934 uint32_t version;
935 const char * const name;
936};
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -0600937#define MEM_TRACKER_LAYER_EXT_ARRAY_SIZE 2
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600938static const VkExtensionProperties mtExts[MEM_TRACKER_LAYER_EXT_ARRAY_SIZE] = {
939 {
940 VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES,
941 "MemTracker",
942 0x10,
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -0600943 "Validation layer: MemTracker",
944 },
945 {
946 VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES,
947 "Validation",
948 0x10,
949 "Validation layer: MemTracker",
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600950 }
Jon Ashburneb2728b2015-04-10 14:33:07 -0600951};
952
953VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalExtensionInfo(
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600954 VkExtensionInfoType infoType,
955 uint32_t extensionIndex,
956 size_t *pDataSize,
957 void *pData)
Jon Ashburneb2728b2015-04-10 14:33:07 -0600958{
Mark Lobodzinski5f25be42015-05-14 15:08:13 -0500959 // This entrypoint is NOT going to init its own dispatch table since loader calls here early
Jon Ashburneb2728b2015-04-10 14:33:07 -0600960 uint32_t *count;
961
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600962 if (pDataSize == NULL) {
Jon Ashburneb2728b2015-04-10 14:33:07 -0600963 return VK_ERROR_INVALID_POINTER;
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600964 }
Jon Ashburneb2728b2015-04-10 14:33:07 -0600965
966 switch (infoType) {
967 case VK_EXTENSION_INFO_TYPE_COUNT:
968 *pDataSize = sizeof(uint32_t);
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600969 if (pData == NULL) {
Jon Ashburneb2728b2015-04-10 14:33:07 -0600970 return VK_SUCCESS;
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600971 }
Jon Ashburneb2728b2015-04-10 14:33:07 -0600972 count = (uint32_t *) pData;
973 *count = MEM_TRACKER_LAYER_EXT_ARRAY_SIZE;
974 break;
975 case VK_EXTENSION_INFO_TYPE_PROPERTIES:
976 *pDataSize = sizeof(VkExtensionProperties);
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600977 if (pData == NULL) {
Jon Ashburneb2728b2015-04-10 14:33:07 -0600978 return VK_SUCCESS;
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600979 }
980 if (extensionIndex >= MEM_TRACKER_LAYER_EXT_ARRAY_SIZE) {
Jon Ashburneb2728b2015-04-10 14:33:07 -0600981 return VK_ERROR_INVALID_VALUE;
Mark Lobodzinskia908b162015-04-21 15:33:04 -0600982 }
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600983 memcpy((VkExtensionProperties *) pData, &mtExts[extensionIndex], sizeof(VkExtensionProperties));
Jon Ashburneb2728b2015-04-10 14:33:07 -0600984 break;
985 default:
986 return VK_ERROR_INVALID_VALUE;
987 };
988
989 return VK_SUCCESS;
990}
991
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -0600992VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionInfo(
993 VkPhysicalDevice physical_device,
994 VkExtensionInfoType infoType,
995 uint32_t extensionIndex,
996 size_t *pDataSize,
997 void *pData)
998{
999 uint32_t *count;
1000
1001 if (pDataSize == NULL) {
1002 return VK_ERROR_INVALID_POINTER;
1003 }
1004
1005 switch (infoType) {
1006 case VK_EXTENSION_INFO_TYPE_COUNT:
1007 *pDataSize = sizeof(uint32_t);
1008 if (pData == NULL) {
1009 return VK_SUCCESS;
1010 }
1011 count = (uint32_t *) pData;
1012 *count = MEM_TRACKER_LAYER_EXT_ARRAY_SIZE;
1013 break;
1014 case VK_EXTENSION_INFO_TYPE_PROPERTIES:
1015 *pDataSize = sizeof(VkExtensionProperties);
1016 if (pData == NULL) {
1017 return VK_SUCCESS;
1018 }
1019 if (extensionIndex >= MEM_TRACKER_LAYER_EXT_ARRAY_SIZE) {
1020 return VK_ERROR_INVALID_VALUE;
1021 }
1022 memcpy((VkExtensionProperties *) pData, &mtExts[extensionIndex], sizeof(VkExtensionProperties));
1023 break;
1024 default:
1025 return VK_ERROR_INVALID_VALUE;
1026 }
1027
1028 return VK_SUCCESS;
1029}
1030
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001031VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(
1032 VkDevice device,
1033 uint32_t queueNodeIndex,
1034 uint32_t queueIndex,
1035 VkQueue *pQueue)
Mark Lobodzinski55e53d92015-03-31 16:05:35 -05001036{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001037 VkResult result = device_dispatch_table(device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001038 if (result == VK_SUCCESS) {
Mark Lobodzinskibe783fe2015-04-07 13:38:21 -05001039 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001040 add_queue_info(*pQueue);
Mark Lobodzinskibe783fe2015-04-07 13:38:21 -05001041 loader_platform_thread_unlock_mutex(&globalLock);
1042 }
Mark Lobodzinski55e53d92015-03-31 16:05:35 -05001043 return result;
1044}
1045
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001046VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(
1047 VkQueue queue,
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001048 uint32_t cmdBufferCount,
1049 const VkCmdBuffer *pCmdBuffers,
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001050 VkFence fence)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001051{
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001052 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001053 // TODO : Need to track fence and clear mem references when fence clears
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -05001054 MT_CB_INFO* pCBInfo = NULL;
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001055 uint64_t fenceId = add_fence_info(fence, queue);
Mark Lobodzinskibe783fe2015-04-07 13:38:21 -05001056
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001057 print_mem_list();
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -05001058 printCBList();
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001059 for (uint32_t i = 0; i < cmdBufferCount; i++) {
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001060 pCBInfo = get_cmd_buf_info(pCmdBuffers[i]);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -05001061 pCBInfo->fenceId = fenceId;
Mike Stroyan53430332015-05-19 15:16:08 -06001062 pCBInfo->lastSubmittedFence = fence;
1063 pCBInfo->lastSubmittedQueue = queue;
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001064 }
Mark Lobodzinskibe783fe2015-04-07 13:38:21 -05001065
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001066 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001067 VkResult result = device_dispatch_table(queue)->QueueSubmit(
1068 queue, cmdBufferCount, pCmdBuffers, fence);
Courtney Goeltzenleuchtercfedf362015-04-02 13:39:07 -06001069 return result;
1070}
1071
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001072VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(
1073 VkDevice device,
1074 const VkMemoryAllocInfo *pAllocInfo,
1075 VkDeviceMemory *pMem)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001076{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001077 VkResult result = device_dispatch_table(device)->AllocMemory(device, pAllocInfo, pMem);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001078 // TODO : Track allocations and overall size here
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001079 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001080 add_mem_obj_info(*pMem, pAllocInfo);
1081 print_mem_list();
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001082 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001083 return result;
1084}
1085
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001086VK_LAYER_EXPORT VkResult VKAPI vkFreeMemory(
1087 VkDevice device,
1088 VkDeviceMemory mem)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001089{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001090 /* From spec : A memory object is freed by calling vkFreeMemory() when it is no longer needed. Before
Tobin Ehlisa747e682014-11-25 14:47:20 -07001091 * freeing a memory object, an application must ensure the memory object is unbound from
1092 * all API objects referencing it and that it is not referenced by any queued command buffers
1093 */
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001094 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinski5f25be42015-05-14 15:08:13 -05001095 bool32_t noerror = freeMemObjInfo(mem, false);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001096 print_mem_list();
1097 print_object_list();
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -05001098 printCBList();
Mark Lobodzinski5f25be42015-05-14 15:08:13 -05001099 // Output an warning message for proper error/warning handling
1100 if (noerror == VK_FALSE) {
1101 char str[1024];
1102 sprintf(str, "Freeing memory object while it still has references: mem obj %p", (void*)mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001103 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_DESTROY_OBJECT_ERROR, "MEM", str);
Mark Lobodzinski5f25be42015-05-14 15:08:13 -05001104 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001105 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001106 VkResult result = device_dispatch_table(device)->FreeMemory(device, mem);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001107 return result;
1108}
1109
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001110VK_LAYER_EXPORT VkResult VKAPI vkSetMemoryPriority(
1111 VkDevice device,
1112 VkDeviceMemory mem,
1113 VkMemoryPriority priority)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001114{
1115 // TODO : Update tracking for this alloc
1116 // Make sure memory is not pinned, which can't have priority set
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001117 VkResult result = device_dispatch_table(device)->SetMemoryPriority(device, mem, priority);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001118 return result;
1119}
1120
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001121VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(
1122 VkDevice device,
1123 VkDeviceMemory mem,
1124 VkDeviceSize offset,
1125 VkDeviceSize size,
1126 VkFlags flags,
1127 void **ppData)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001128{
1129 // TODO : Track when memory is mapped
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001130 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001131 MT_MEM_OBJ_INFO *pMemObj = get_mem_obj_info(mem);
Tony Barbour8205d902015-04-16 15:59:00 -06001132 if ((pMemObj->allocInfo.memProps & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0) {
Mark Lobodzinski06f60b82015-02-25 12:16:04 -06001133 char str[1024];
Mark Lobodzinski5f25be42015-05-14 15:08:13 -05001134 sprintf(str, "Mapping Memory without VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT set: mem obj %p", (void*)mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001135 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str);
Mark Lobodzinski06f60b82015-02-25 12:16:04 -06001136 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001137 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001138 VkResult result = device_dispatch_table(device)->MapMemory(device, mem, offset, size, flags, ppData);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001139 return result;
1140}
1141
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001142VK_LAYER_EXPORT VkResult VKAPI vkUnmapMemory(
1143 VkDevice device,
1144 VkDeviceMemory mem)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001145{
1146 // TODO : Track as memory gets unmapped, do we want to check what changed following map?
1147 // Make sure that memory was ever mapped to begin with
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001148 VkResult result = device_dispatch_table(device)->UnmapMemory(device, mem);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001149 return result;
1150}
1151
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001152VK_LAYER_EXPORT VkResult VKAPI vkPinSystemMemory(
1153 VkDevice device,
1154 const void *pSysMem,
1155 size_t memSize,
1156 VkDeviceMemory *pMem)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001157{
1158 // TODO : Track this
1159 // Verify that memory is actually pinnable
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001160 VkResult result = device_dispatch_table(device)->PinSystemMemory(device, pSysMem, memSize, pMem);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001161 return result;
1162}
1163
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001164VK_LAYER_EXPORT VkResult VKAPI vkOpenSharedMemory(
1165 VkDevice device,
1166 const VkMemoryOpenInfo *pOpenInfo,
1167 VkDeviceMemory *pMem)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001168{
1169 // TODO : Track this
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001170 VkResult result = device_dispatch_table(device)->OpenSharedMemory(device, pOpenInfo, pMem);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001171 return result;
1172}
1173
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001174VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerMemory(
1175 VkDevice device,
1176 const VkPeerMemoryOpenInfo *pOpenInfo,
1177 VkDeviceMemory *pMem)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001178{
1179 // TODO : Track this
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001180 VkResult result = device_dispatch_table(device)->OpenPeerMemory(device, pOpenInfo, pMem);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001181 return result;
1182}
1183
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001184VK_LAYER_EXPORT VkResult VKAPI vkOpenPeerImage(
1185 VkDevice device,
1186 const VkPeerImageOpenInfo *pOpenInfo,
1187 VkImage *pImage,
1188 VkDeviceMemory *pMem)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001189{
1190 // TODO : Track this
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001191 VkResult result = device_dispatch_table(device)->OpenPeerImage(device, pOpenInfo, pImage, pMem);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001192 return result;
1193}
1194
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001195VK_LAYER_EXPORT VkResult VKAPI vkDestroyObject(
1196 VkDevice device,
1197 VkObjectType objType,
1198 VkObject object)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001199{
Mike Stroyan988caa42015-05-19 17:03:40 -06001200 unordered_map<VkObject, MT_OBJ_INFO>::iterator item;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001201 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinski283a4c22015-03-24 16:29:24 -05001202
Mike Stroyan53430332015-05-19 15:16:08 -06001203 // First check if this is a CmdBuffer or fence
1204 switch (objType) {
1205 case VK_OBJECT_TYPE_COMMAND_BUFFER:
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001206 delete_cmd_buf_info((VkCmdBuffer)object);
Mike Stroyan53430332015-05-19 15:16:08 -06001207 break;
1208 case VK_OBJECT_TYPE_FENCE:
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001209 delete_fence_info((VkFence)object);
Mike Stroyan53430332015-05-19 15:16:08 -06001210 break;
1211 default:
1212 break;
Tobin Ehlise6884ef2014-11-27 07:52:04 -07001213 }
Mark Lobodzinski283a4c22015-03-24 16:29:24 -05001214
Mike Stroyan53430332015-05-19 15:16:08 -06001215 if ((item = objectMap.find(object)) != objectMap.end()) {
Mike Stroyan988caa42015-05-19 17:03:40 -06001216 MT_OBJ_INFO* pDelInfo = &(*item).second;
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -05001217 if (pDelInfo->pMemObjInfo) {
Tobin Ehlise6884ef2014-11-27 07:52:04 -07001218 // Wsi allocated Memory is tied to image object so clear the binding and free that memory automatically
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -05001219 if (0 == pDelInfo->pMemObjInfo->allocInfo.allocationSize) { // Wsi allocated memory has NULL allocInfo w/ 0 size
Tony Barbour8205d902015-04-16 15:59:00 -06001220 VkDeviceMemory memToFree = pDelInfo->pMemObjInfo->mem;
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001221 clear_object_binding(object);
Courtney Goeltzenleuchterc4804862015-03-26 16:15:39 -06001222 freeMemObjInfo(memToFree, true);
1223 }
1224 else {
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001225 // Remove this object from memory object's reference list and decrement its ref counter
1226 clear_object_binding(object);
Tobin Ehlise6884ef2014-11-27 07:52:04 -07001227 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001228 }
Mike Stroyan53430332015-05-19 15:16:08 -06001229 objectMap.erase(item);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001230 }
Mark Lobodzinski283a4c22015-03-24 16:29:24 -05001231
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001232 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001233 VkResult result = device_dispatch_table(device)->DestroyObject(device, objType, object);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001234 return result;
1235}
1236
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001237VK_LAYER_EXPORT VkResult VKAPI vkGetObjectInfo(
1238 VkDevice device,
1239 VkObjectType objType,
1240 VkObject object,
1241 VkObjectInfoType infoType,
1242 size_t *pDataSize,
1243 void *pData)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001244{
1245 // TODO : What to track here?
Mark Lobodzinskifb9f5642015-05-11 17:21:15 -05001246 // Could potentially save returned mem requirements and validate values passed into BindObjectMemory for this object
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001247 // From spec : The only objects that are guaranteed to have no external memory requirements are devices, queues,
1248 // command buffers, shaders and memory objects.
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001249 VkResult result = device_dispatch_table(device)->GetObjectInfo(device, objType, object, infoType, pDataSize, pData);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001250 return result;
1251}
1252
Mark Lobodzinskifb9f5642015-05-11 17:21:15 -05001253VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(
1254 VkDevice device,
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001255 VkObjectType objType,
1256 VkObject object,
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001257 VkDeviceMemory mem,
1258 VkDeviceSize offset)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001259{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001260 VkResult result = device_dispatch_table(device)->BindObjectMemory(device, objType, object, mem, offset);
Mike Stroyan230e6252015-04-17 12:36:38 -06001261 loader_platform_thread_lock_mutex(&globalLock);
1262 // Track objects tied to memory
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001263 set_object_binding(object, mem);
1264 print_object_list();
1265 print_mem_list();
Mike Stroyan230e6252015-04-17 12:36:38 -06001266 loader_platform_thread_unlock_mutex(&globalLock);
1267 return result;
1268}
1269
Mark Lobodzinskifb9f5642015-05-11 17:21:15 -05001270VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001271 VkQueue queue,
Mark Lobodzinskifb9f5642015-05-11 17:21:15 -05001272 VkBuffer buffer,
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001273 VkDeviceSize rangeOffset,
1274 VkDeviceSize rangeSize,
1275 VkDeviceMemory mem,
1276 VkDeviceSize memOffset)
Mike Stroyan230e6252015-04-17 12:36:38 -06001277{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001278 VkResult result = device_dispatch_table(queue)->QueueBindSparseBufferMemory(
1279 queue, buffer, rangeOffset, rangeSize, mem, memOffset);
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001280 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001281 // Track objects tied to memory
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001282 if (VK_FALSE == set_sparse_buffer_binding(buffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001283 char str[1024];
Mark Lobodzinskifb9f5642015-05-11 17:21:15 -05001284 sprintf(str, "Unable to set object %p binding to mem obj %p", (void*)buffer, (void*)mem);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001285 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER, buffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07001286 }
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001287 print_object_list();
1288 print_mem_list();
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001289 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001290 return result;
1291}
1292
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001293VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(
1294 VkDevice device,
1295 const VkFenceCreateInfo *pCreateInfo,
1296 VkFence *pFence)
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001297{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001298 VkResult result = device_dispatch_table(device)->CreateFence(device, pCreateInfo, pFence);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001299 if (VK_SUCCESS == result) {
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001300 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001301 add_object_info(*pFence, pCreateInfo->sType, pCreateInfo, sizeof(VkFenceCreateInfo), "fence");
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001302 loader_platform_thread_unlock_mutex(&globalLock);
1303 }
1304 return result;
1305}
1306
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001307VK_LAYER_EXPORT VkResult VKAPI vkResetFences(
1308 VkDevice device,
1309 uint32_t fenceCount,
1310 VkFence *pFences)
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -05001311{
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -06001312 /*
1313 * TODO: Shouldn't we check for error conditions before passing down the chain?
1314 * What if reason result is not VK_SUCCESS is something we could report as a validation error?
1315 */
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001316 VkResult result = device_dispatch_table(device)->ResetFences(device, fenceCount, pFences);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001317 if (VK_SUCCESS == result) {
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -05001318 loader_platform_thread_lock_mutex(&globalLock);
1319 // Reset fence state in fenceCreateInfo structure
1320 for (uint32_t i = 0; i < fenceCount; i++) {
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001321 MT_OBJ_INFO* pObjectInfo = get_object_info(pFences[i]);
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -05001322 if (pObjectInfo != NULL) {
Mark Lobodzinski56945182015-04-09 13:46:09 -05001323 // Validate fences in SIGNALED state
Tobin Ehlisf29da382015-04-15 07:46:12 -06001324 if (!(pObjectInfo->create_info.fence_create_info.flags & VK_FENCE_CREATE_SIGNALED_BIT)) {
Mark Lobodzinski56945182015-04-09 13:46:09 -05001325 char str[1024];
Mark Lobodzinski610be622015-04-14 14:09:32 -05001326 sprintf(str, "Fence %p submitted to VkResetFences in UNSIGNALED STATE", pFences[i]);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001327 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
Tobin Ehlisf29da382015-04-15 07:46:12 -06001328 result = VK_ERROR_INVALID_VALUE;
Mark Lobodzinski56945182015-04-09 13:46:09 -05001329 }
1330 else {
1331 pObjectInfo->create_info.fence_create_info.flags =
Tobin Ehlisf29da382015-04-15 07:46:12 -06001332 static_cast<VkFenceCreateFlags>(pObjectInfo->create_info.fence_create_info.flags & ~VK_FENCE_CREATE_SIGNALED_BIT);
Mark Lobodzinski56945182015-04-09 13:46:09 -05001333 }
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -05001334 }
1335 }
1336 loader_platform_thread_unlock_mutex(&globalLock);
1337 }
1338 return result;
1339}
1340
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001341VK_LAYER_EXPORT VkResult VKAPI vkGetFenceStatus(
1342 VkDevice device,
1343 VkFence fence)
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001344{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001345 VkResult result = device_dispatch_table(device)->GetFenceStatus(device, fence);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001346 if (VK_SUCCESS == result) {
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05001347 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001348 update_fence_tracking(fence);
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05001349 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001350 }
1351 return result;
1352}
1353
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001354VK_LAYER_EXPORT VkResult VKAPI vkWaitForFences(
1355 VkDevice device,
1356 uint32_t fenceCount,
1357 const VkFence *pFences,
1358 bool32_t waitAll,
1359 uint64_t timeout)
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001360{
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -05001361 // Verify fence status of submitted fences
1362 for(uint32_t i = 0; i < fenceCount; i++) {
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001363 MT_OBJ_INFO* pObjectInfo = get_object_info(pFences[i]);
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -05001364 if (pObjectInfo != NULL) {
Tobin Ehlisf29da382015-04-15 07:46:12 -06001365 if (pObjectInfo->create_info.fence_create_info.flags & VK_FENCE_CREATE_SIGNALED_BIT) {
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -05001366 char str[1024];
Mark Lobodzinski610be622015-04-14 14:09:32 -05001367 sprintf(str, "VkWaitForFences specified fence %p already in SIGNALED state.", pFences[i]);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001368 layerCbMsg(VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM", str);
Mark Lobodzinskiebe814d2015-04-07 16:07:57 -05001369 }
1370 }
1371 }
1372
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001373 VkResult result = device_dispatch_table(device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05001374 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinski8ee96342015-04-02 20:49:09 -05001375
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001376 if (VK_SUCCESS == result) {
Mark Lobodzinski8ee96342015-04-02 20:49:09 -05001377 if (waitAll || fenceCount == 1) { // Clear all the fences
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001378 for(uint32_t i = 0; i < fenceCount; i++) {
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001379 update_fence_tracking(pFences[i]);
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001380 }
1381 }
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001382 }
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05001383 loader_platform_thread_unlock_mutex(&globalLock);
1384 return result;
1385}
1386
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001387VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(
1388 VkQueue queue)
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05001389{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001390 VkResult result = device_dispatch_table(queue)->QueueWaitIdle(queue);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001391 if (VK_SUCCESS == result) {
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05001392 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001393 retire_queue_fences(queue);
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05001394 loader_platform_thread_unlock_mutex(&globalLock);
1395 }
1396 return result;
1397}
1398
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001399VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(
1400 VkDevice device)
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05001401{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001402 VkResult result = device_dispatch_table(device)->DeviceWaitIdle(device);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001403 if (VK_SUCCESS == result) {
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05001404 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001405 retire_device_fences(device);
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05001406 loader_platform_thread_unlock_mutex(&globalLock);
1407 }
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001408 return result;
1409}
1410
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001411VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(
1412 VkDevice device,
1413 const VkEventCreateInfo *pCreateInfo,
1414 VkEvent *pEvent)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001415{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001416 VkResult result = device_dispatch_table(device)->CreateEvent(device, pCreateInfo, pEvent);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001417 if (VK_SUCCESS == result) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001418 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001419 add_object_info(*pEvent, pCreateInfo->sType, pCreateInfo, sizeof(VkEventCreateInfo), "event");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001420 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski15427102015-02-18 16:38:17 -06001421 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001422 return result;
1423}
1424
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001425VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(
1426 VkDevice device,
1427 const VkQueryPoolCreateInfo *pCreateInfo,
1428 VkQueryPool *pQueryPool)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001429{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001430 VkResult result = device_dispatch_table(device)->CreateQueryPool(device, pCreateInfo, pQueryPool);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001431 if (VK_SUCCESS == result) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001432 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001433 add_object_info(*pQueryPool, pCreateInfo->sType, pCreateInfo, sizeof(VkQueryPoolCreateInfo), "query_pool");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001434 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski15427102015-02-18 16:38:17 -06001435 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001436 return result;
1437}
1438
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001439VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(
1440 VkDevice device,
1441 const VkBufferCreateInfo *pCreateInfo,
1442 VkBuffer *pBuffer)
Tobin Ehlis84c521c2015-01-19 08:42:29 -07001443{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001444 VkResult result = device_dispatch_table(device)->CreateBuffer(device, pCreateInfo, pBuffer);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001445 if (VK_SUCCESS == result) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001446 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001447 add_object_info(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferCreateInfo), "buffer");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001448 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski15427102015-02-18 16:38:17 -06001449 }
Tobin Ehlis84c521c2015-01-19 08:42:29 -07001450 return result;
1451}
1452
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001453VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(
1454 VkDevice device,
1455 const VkBufferViewCreateInfo *pCreateInfo,
1456 VkBufferView *pView)
Tobin Ehlis84c521c2015-01-19 08:42:29 -07001457{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001458 VkResult result = device_dispatch_table(device)->CreateBufferView(device, pCreateInfo, pView);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001459 if (result == VK_SUCCESS) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001460 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001461 add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferViewCreateInfo), "buffer_view");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001462 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski15427102015-02-18 16:38:17 -06001463 }
Tobin Ehlis84c521c2015-01-19 08:42:29 -07001464 return result;
1465}
1466
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001467VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
1468 VkDevice device,
1469 const VkImageCreateInfo *pCreateInfo,
1470 VkImage *pImage)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001471{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001472 VkResult result = device_dispatch_table(device)->CreateImage(device, pCreateInfo, pImage);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001473 if (VK_SUCCESS == result) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001474 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001475 add_object_info(*pImage, pCreateInfo->sType, pCreateInfo, sizeof(VkImageCreateInfo), "image");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001476 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001477 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001478 return result;
1479}
1480
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001481VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
1482 VkDevice device,
1483 const VkImageViewCreateInfo *pCreateInfo,
1484 VkImageView *pView)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001485{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001486 VkResult result = device_dispatch_table(device)->CreateImageView(device, pCreateInfo, pView);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001487 if (result == VK_SUCCESS) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001488 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001489 add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkImageViewCreateInfo), "image_view");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001490 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001491 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001492 return result;
1493}
1494
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001495VK_LAYER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(
1496 VkDevice device,
1497 const VkColorAttachmentViewCreateInfo *pCreateInfo,
1498 VkColorAttachmentView *pView)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001499{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001500 VkResult result = device_dispatch_table(device)->CreateColorAttachmentView(device, pCreateInfo, pView);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001501 if (result == VK_SUCCESS) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001502 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001503 add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkColorAttachmentViewCreateInfo), "color_attachment_view");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001504 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001505 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001506 return result;
1507}
1508
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001509VK_LAYER_EXPORT VkResult VKAPI vkCreateDepthStencilView(
1510 VkDevice device,
1511 const VkDepthStencilViewCreateInfo *pCreateInfo,
1512 VkDepthStencilView *pView)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001513{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001514 VkResult result = device_dispatch_table(device)->CreateDepthStencilView(device, pCreateInfo, pView);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001515 if (result == VK_SUCCESS) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001516 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001517 add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkDepthStencilViewCreateInfo), "ds_view");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001518 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001519 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001520 return result;
1521}
1522
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001523VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
1524 VkDevice device,
1525 const VkShaderCreateInfo *pCreateInfo,
1526 VkShader *pShader)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001527{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001528 VkResult result = device_dispatch_table(device)->CreateShader(device, pCreateInfo, pShader);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001529 return result;
1530}
1531
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001532VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(
1533 VkDevice device,
1534 const VkGraphicsPipelineCreateInfo *pCreateInfo,
1535 VkPipeline *pPipeline)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001536{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001537 VkResult result = device_dispatch_table(device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001538 if (result == VK_SUCCESS) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001539 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001540 add_object_info(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo), "graphics_pipeline");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001541 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001542 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001543 return result;
1544}
1545
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -06001546VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative(
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001547 VkDevice device,
1548 const VkGraphicsPipelineCreateInfo *pCreateInfo,
1549 VkPipeline basePipeline,
1550 VkPipeline *pPipeline)
Courtney Goeltzenleuchter32876a12015-03-25 15:37:49 -06001551{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001552 VkResult result = device_dispatch_table(device)->CreateGraphicsPipelineDerivative(
1553 device, pCreateInfo, basePipeline, pPipeline);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001554 if (result == VK_SUCCESS) {
Courtney Goeltzenleuchter32876a12015-03-25 15:37:49 -06001555 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001556 add_object_info(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo), "graphics_pipeline");
Courtney Goeltzenleuchter32876a12015-03-25 15:37:49 -06001557 loader_platform_thread_unlock_mutex(&globalLock);
1558 }
1559 return result;
1560}
1561
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001562VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipeline(
1563 VkDevice device,
1564 const VkComputePipelineCreateInfo *pCreateInfo,
1565 VkPipeline *pPipeline)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001566{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001567 VkResult result = device_dispatch_table(device)->CreateComputePipeline(device, pCreateInfo, pPipeline);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001568 if (result == VK_SUCCESS) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001569 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001570 add_object_info(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkComputePipelineCreateInfo), "compute_pipeline");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001571 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001572 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001573 return result;
1574}
1575
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001576VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(
1577 VkDevice device,
1578 const VkSamplerCreateInfo *pCreateInfo,
1579 VkSampler *pSampler)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001580{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001581 VkResult result = device_dispatch_table(device)->CreateSampler(device, pCreateInfo, pSampler);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001582 if (result == VK_SUCCESS) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001583 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001584 add_object_info(*pSampler, pCreateInfo->sType, pCreateInfo, sizeof(VkSamplerCreateInfo), "sampler");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001585 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001586 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001587 return result;
1588}
1589
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001590VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(
1591 VkDevice device,
1592 const VkDynamicVpStateCreateInfo *pCreateInfo,
1593 VkDynamicVpState *pState)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001594{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001595 VkResult result = device_dispatch_table(device)->CreateDynamicViewportState(device, pCreateInfo, pState);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001596 if (result == VK_SUCCESS) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001597 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001598 add_object_info(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicVpStateCreateInfo), "viewport_state");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001599 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001600 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001601 return result;
1602}
1603
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001604VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(
1605 VkDevice device,
1606 const VkDynamicRsStateCreateInfo *pCreateInfo,
1607 VkDynamicRsState *pState)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001608{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001609 VkResult result = device_dispatch_table(device)->CreateDynamicRasterState(device, pCreateInfo, pState);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001610 if (result == VK_SUCCESS) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001611 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001612 add_object_info(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicRsStateCreateInfo), "raster_state");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001613 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001614 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001615 return result;
1616}
1617
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001618VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(
1619 VkDevice device,
1620 const VkDynamicCbStateCreateInfo *pCreateInfo,
1621 VkDynamicCbState *pState)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001622{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001623 VkResult result = device_dispatch_table(device)->CreateDynamicColorBlendState(device, pCreateInfo, pState);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001624 if (result == VK_SUCCESS) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001625 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001626 add_object_info(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicCbStateCreateInfo), "cb_state");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001627 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001628 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001629 return result;
1630}
1631
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001632VK_LAYER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(
1633 VkDevice device,
1634 const VkDynamicDsStateCreateInfo *pCreateInfo,
1635 VkDynamicDsState *pState)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001636{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001637 VkResult result = device_dispatch_table(device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001638 if (result == VK_SUCCESS) {
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001639 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001640 add_object_info(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicDsStateCreateInfo), "ds_state");
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001641 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis6aa77422015-01-07 17:49:29 -07001642 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001643 return result;
1644}
1645
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001646VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(
1647 VkDevice device,
1648 const VkCmdBufferCreateInfo *pCreateInfo,
1649 VkCmdBuffer *pCmdBuffer)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001650{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001651 VkResult result = device_dispatch_table(device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
Mark Lobodzinski85a83982015-04-02 08:52:53 -05001652 // At time of cmd buffer creation, create global cmd buffer info for the returned cmd buffer
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001653 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001654 if (*pCmdBuffer)
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001655 add_cmd_buf_info(*pCmdBuffer);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -05001656 printCBList();
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001657 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001658 return result;
1659}
1660
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001661VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(
1662 VkCmdBuffer cmdBuffer,
1663 const VkCmdBufferBeginInfo *pBeginInfo)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001664{
Mike Stroyan53430332015-05-19 15:16:08 -06001665 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001666 // This implicitly resets the Cmd Buffer so make sure any fence is done and then clear memory references
Mike Stroyan53430332015-05-19 15:16:08 -06001667 if (!checkCBCompleted(cmdBuffer)) {
1668 char str[1024];
1669 sprintf(str, "Calling vkBeginCommandBuffer() on active CB %p before it has completed. "
1670 "You must check CB flag before this call.", cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001671 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001672 }
Mike Stroyan53430332015-05-19 15:16:08 -06001673 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001674 VkResult result = device_dispatch_table(cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo);
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001675 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001676 clear_cmd_buf_and_mem_references(cmdBuffer);
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001677 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001678 return result;
1679}
1680
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001681VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(
1682 VkCmdBuffer cmdBuffer)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001683{
1684 // TODO : Anything to do here?
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001685 VkResult result = device_dispatch_table(cmdBuffer)->EndCommandBuffer(cmdBuffer);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001686 return result;
1687}
1688
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001689VK_LAYER_EXPORT VkResult VKAPI vkResetCommandBuffer(
1690 VkCmdBuffer cmdBuffer)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001691{
Mike Stroyan53430332015-05-19 15:16:08 -06001692 loader_platform_thread_lock_mutex(&globalLock);
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001693 // Verify that CB is complete (not in-flight)
Mike Stroyan53430332015-05-19 15:16:08 -06001694 if (!checkCBCompleted(cmdBuffer)) {
1695 char str[1024];
1696 sprintf(str, "Resetting CB %p before it has completed. You must check CB flag before "
1697 "calling vkResetCommandBuffer().", cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001698 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
Tobin Ehlis77b3abb2015-03-04 08:38:22 -07001699 }
1700 // Clear memory references as this point.
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001701 clear_cmd_buf_and_mem_references(cmdBuffer);
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001702 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001703 VkResult result = device_dispatch_table(cmdBuffer)->ResetCommandBuffer(cmdBuffer);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001704 return result;
1705}
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001706// TODO : For any vkCmdBind* calls that include an object which has mem bound to it,
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001707// need to account for that mem now having binding to given cmdBuffer
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001708VK_LAYER_EXPORT void VKAPI vkCmdBindPipeline(
1709 VkCmdBuffer cmdBuffer,
1710 VkPipelineBindPoint pipelineBindPoint,
1711 VkPipeline pipeline)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001712{
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001713#if 0
1714 // TODO : If memory bound to pipeline, then need to tie that mem to cmdBuffer
1715 if (getPipeline(pipeline)) {
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001716 MT_CB_INFO *pCBInfo = get_cmd_buf_info(cmdBuffer);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -05001717 if (pCBInfo) {
1718 pCBInfo->pipelines[pipelineBindPoint] = pipeline;
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001719 } else {
1720 char str[1024];
1721 sprintf(str, "Attempt to bind Pipeline %p to non-existant command buffer %p!", (void*)pipeline, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001722 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_INVALID_CB, (char *) "DS", (char *) str);
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001723 }
1724 }
1725 else {
1726 char str[1024];
1727 sprintf(str, "Attempt to bind Pipeline %p that doesn't exist!", (void*)pipeline);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001728 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline, 0, MEMTRACK_INVALID_OBJECT, (char *) "DS", (char *) str);
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001729 }
1730#endif
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001731 device_dispatch_table(cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001732}
1733
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001734VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(
1735 VkCmdBuffer cmdBuffer,
1736 VkStateBindPoint stateBindPoint,
1737 VkDynamicStateObject state)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001738{
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -05001739 MT_OBJ_INFO *pObjInfo;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001740 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001741 MT_CB_INFO *pCmdBuf = get_cmd_buf_info(cmdBuffer);
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001742 if (!pCmdBuf) {
1743 char str[1024];
1744 sprintf(str, "Unable to find command buffer object %p, was it ever created?", (void*)cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001745 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_INVALID_CB, "DD", str);
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001746 }
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001747 pObjInfo = get_object_info(state);
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -05001748 if (!pObjInfo) {
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001749 char str[1024];
1750 sprintf(str, "Unable to find dynamic state object %p, was it ever created?", (void*)state);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001751 /* TODO: put in real object type */
1752 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, state, 0, MEMTRACK_INVALID_OBJECT, "DD", str);
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001753 }
Mark Lobodzinski7a428ce2015-03-31 16:05:35 -05001754 pCmdBuf->pDynamicState[stateBindPoint] = pObjInfo;
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001755 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001756 device_dispatch_table(cmdBuffer)->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001757}
1758
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001759VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001760 VkCmdBuffer cmdBuffer,
1761 VkPipelineBindPoint pipelineBindPoint,
1762 uint32_t firstSet,
1763 uint32_t setCount,
1764 const VkDescriptorSet *pDescriptorSets,
1765 uint32_t dynamicOffsetCount,
1766 const uint32_t *pDynamicOffsets)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001767{
Tobin Ehlis2836a7d2015-01-08 15:22:32 -07001768 // TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001769 device_dispatch_table(cmdBuffer)->CmdBindDescriptorSets(
1770 cmdBuffer, pipelineBindPoint, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001771}
1772
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -06001773VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001774 VkCmdBuffer cmdBuffer,
1775 uint32_t startBinding,
1776 uint32_t bindingCount,
1777 const VkBuffer *pBuffers,
1778 const VkDeviceSize *pOffsets)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001779{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001780 device_dispatch_table(cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
Chia-I Wufb5062e2015-01-05 13:42:56 +08001781}
1782
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001783VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(
1784 VkCmdBuffer cmdBuffer,
1785 VkBuffer buffer,
1786 VkDeviceSize offset,
1787 VkIndexType indexType)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001788{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001789 device_dispatch_table(cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001790}
1791
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001792VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(
1793 VkCmdBuffer cmdBuffer,
1794 VkBuffer buffer,
1795 VkDeviceSize offset,
1796 uint32_t count,
1797 uint32_t stride)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001798{
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001799 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001800 VkDeviceMemory mem = get_mem_binding_from_object(buffer);
1801 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001802 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001803 sprintf(str, "In vkCmdDrawIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001804 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07001805 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001806 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001807 device_dispatch_table(cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001808}
1809
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001810VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(
1811 VkCmdBuffer cmdBuffer,
1812 VkBuffer buffer,
1813 VkDeviceSize offset,
1814 uint32_t count,
1815 uint32_t stride)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001816{
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001817 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001818 VkDeviceMemory mem = get_mem_binding_from_object(buffer);
1819 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001820 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001821 sprintf(str, "In vkCmdDrawIndexedIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001822 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07001823 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001824 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001825 device_dispatch_table(cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001826}
1827
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001828VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(
1829 VkCmdBuffer cmdBuffer,
1830 VkBuffer buffer,
1831 VkDeviceSize offset)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001832{
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001833 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001834 VkDeviceMemory mem = get_mem_binding_from_object(buffer);
1835 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001836 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001837 sprintf(str, "In vkCmdDispatchIndirect() call unable to update binding of buffer %p to cmdBuffer %p", buffer, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001838 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07001839 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001840 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001841 device_dispatch_table(cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001842}
1843
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001844VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(
1845 VkCmdBuffer cmdBuffer,
1846 VkBuffer srcBuffer,
1847 VkBuffer destBuffer,
1848 uint32_t regionCount,
1849 const VkBufferCopy *pRegions)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001850{
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001851 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001852 VkDeviceMemory mem = get_mem_binding_from_object(srcBuffer);
1853 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001854 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001855 sprintf(str, "In vkCmdCopyBuffer() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001856 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07001857 }
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001858 mem = get_mem_binding_from_object(destBuffer);
1859 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001860 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001861 sprintf(str, "In vkCmdCopyBuffer() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001862 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07001863 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001864 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001865 device_dispatch_table(cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001866}
1867
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001868VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(
1869 VkCmdBuffer cmdBuffer,
1870 VkImage srcImage,
1871 VkImageLayout srcImageLayout,
1872 VkImage destImage,
1873 VkImageLayout destImageLayout,
1874 uint32_t regionCount,
1875 const VkImageCopy *pRegions)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001876{
1877 // TODO : Each image will have mem mapping so track them
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001878 device_dispatch_table(cmdBuffer)->CmdCopyImage(
1879 cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001880}
1881
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001882VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(
1883 VkCmdBuffer cmdBuffer,
1884 VkImage srcImage,
1885 VkImageLayout srcImageLayout,
1886 VkImage destImage,
1887 VkImageLayout destImageLayout,
1888 uint32_t regionCount,
Mark Lobodzinski20f68592015-05-22 14:43:25 -05001889 const VkImageBlit *pRegions,
1890 VkTexFilter filter)
Courtney Goeltzenleuchterb787a1e2015-03-08 17:02:18 -06001891{
1892 // TODO : Each image will have mem mapping so track them
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001893 device_dispatch_table(cmdBuffer)->CmdBlitImage(
1894 cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
Courtney Goeltzenleuchterb787a1e2015-03-08 17:02:18 -06001895}
1896
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001897VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(
1898 VkCmdBuffer cmdBuffer,
1899 VkBuffer srcBuffer,
1900 VkImage destImage,
1901 VkImageLayout destImageLayout,
1902 uint32_t regionCount,
1903 const VkBufferImageCopy *pRegions)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001904{
1905 // TODO : Track this
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001906 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001907 VkDeviceMemory mem = get_mem_binding_from_object(destImage);
1908 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001909 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001910 sprintf(str, "In vkCmdCopyMemoryToImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001911 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07001912 }
Mark Lobodzinski15427102015-02-18 16:38:17 -06001913
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001914 mem = get_mem_binding_from_object(srcBuffer);
1915 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001916 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001917 sprintf(str, "In vkCmdCopyMemoryToImage() call unable to update binding of srcBuffer %p to cmdBuffer %p", srcBuffer, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001918 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07001919 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001920 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001921 device_dispatch_table(cmdBuffer)->CmdCopyBufferToImage(
1922 cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001923}
1924
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001925VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(
1926 VkCmdBuffer cmdBuffer,
1927 VkImage srcImage,
1928 VkImageLayout srcImageLayout,
1929 VkBuffer destBuffer,
1930 uint32_t regionCount,
1931 const VkBufferImageCopy *pRegions)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001932{
1933 // TODO : Track this
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001934 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001935 VkDeviceMemory mem = get_mem_binding_from_object(srcImage);
1936 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001937 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001938 sprintf(str, "In vkCmdCopyImageToMemory() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001939 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07001940 }
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001941 mem = get_mem_binding_from_object(destBuffer);
1942 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001943 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001944 sprintf(str, "In vkCmdCopyImageToMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001945 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07001946 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001947 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001948 device_dispatch_table(cmdBuffer)->CmdCopyImageToBuffer(
1949 cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001950}
1951
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001952VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(
1953 VkCmdBuffer cmdBuffer,
1954 VkBuffer destBuffer,
1955 VkDeviceSize destOffset,
1956 VkDeviceSize dataSize,
1957 const uint32_t *pData)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001958{
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001959 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001960 VkDeviceMemory mem = get_mem_binding_from_object(destBuffer);
1961 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001962 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001963 sprintf(str, "In vkCmdUpdateMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001964 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07001965 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001966 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001967 device_dispatch_table(cmdBuffer)->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001968}
1969
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001970VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(
1971 VkCmdBuffer cmdBuffer,
1972 VkBuffer destBuffer,
1973 VkDeviceSize destOffset,
1974 VkDeviceSize fillSize,
1975 uint32_t data)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001976{
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001977 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001978 VkDeviceMemory mem = get_mem_binding_from_object(destBuffer);
1979 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07001980 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001981 sprintf(str, "In vkCmdFillMemory() call unable to update binding of destBuffer %p to cmdBuffer %p", destBuffer, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06001982 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07001983 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001984 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05001985 device_dispatch_table(cmdBuffer)->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001986}
1987
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001988VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
1989 VkCmdBuffer cmdBuffer,
1990 VkImage image,
1991 VkImageLayout imageLayout,
Courtney Goeltzenleuchterda4a99e2015-04-23 17:49:22 -06001992 const VkClearColor *pColor,
Mark Lobodzinskia908b162015-04-21 15:33:04 -06001993 uint32_t rangeCount,
1994 const VkImageSubresourceRange *pRanges)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07001995{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06001996 // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06001997 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05001998 VkDeviceMemory mem = get_mem_binding_from_object(image);
1999 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07002000 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002001 sprintf(str, "In vkCmdClearColorImage() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002002 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07002003 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06002004 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002005 device_dispatch_table(cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002006}
2007
Mark Lobodzinskia908b162015-04-21 15:33:04 -06002008VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(
2009 VkCmdBuffer cmdBuffer,
2010 VkImage image,
2011 VkImageLayout imageLayout,
2012 float depth,
2013 uint32_t stencil,
2014 uint32_t rangeCount,
2015 const VkImageSubresourceRange *pRanges)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002016{
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002017 // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06002018 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05002019 VkDeviceMemory mem = get_mem_binding_from_object(image);
2020 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07002021 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002022 sprintf(str, "In vkCmdClearDepthStencil() call unable to update binding of image buffer %p to cmdBuffer %p", image, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002023 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07002024 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06002025 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002026 device_dispatch_table(cmdBuffer)->CmdClearDepthStencil(
2027 cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002028}
2029
Mark Lobodzinskia908b162015-04-21 15:33:04 -06002030VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(
2031 VkCmdBuffer cmdBuffer,
2032 VkImage srcImage,
2033 VkImageLayout srcImageLayout,
2034 VkImage destImage,
2035 VkImageLayout destImageLayout,
2036 uint32_t regionCount,
2037 const VkImageResolve *pRegions)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002038{
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06002039 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05002040 VkDeviceMemory mem = get_mem_binding_from_object(srcImage);
2041 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07002042 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002043 sprintf(str, "In vkCmdResolveImage() call unable to update binding of srcImage buffer %p to cmdBuffer %p", srcImage, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002044 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07002045 }
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05002046 mem = get_mem_binding_from_object(destImage);
2047 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07002048 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002049 sprintf(str, "In vkCmdResolveImage() call unable to update binding of destImage buffer %p to cmdBuffer %p", destImage, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002050 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07002051 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06002052 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002053 device_dispatch_table(cmdBuffer)->CmdResolveImage(
2054 cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002055}
2056
Mark Lobodzinskia908b162015-04-21 15:33:04 -06002057VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(
2058 VkCmdBuffer cmdBuffer,
2059 VkQueryPool queryPool,
2060 uint32_t slot,
2061 VkFlags flags)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002062{
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06002063 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05002064 VkDeviceMemory mem = get_mem_binding_from_object(queryPool);
2065 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07002066 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002067 sprintf(str, "In vkCmdBeginQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002068 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07002069 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06002070 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002071 device_dispatch_table(cmdBuffer)->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002072}
2073
Mark Lobodzinskia908b162015-04-21 15:33:04 -06002074VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(
2075 VkCmdBuffer cmdBuffer,
2076 VkQueryPool queryPool,
2077 uint32_t slot)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002078{
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06002079 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05002080 VkDeviceMemory mem = get_mem_binding_from_object(queryPool);
2081 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07002082 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002083 sprintf(str, "In vkCmdEndQuery() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002084 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07002085 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06002086 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002087 device_dispatch_table(cmdBuffer)->CmdEndQuery(cmdBuffer, queryPool, slot);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002088}
2089
Mark Lobodzinskia908b162015-04-21 15:33:04 -06002090VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(
2091 VkCmdBuffer cmdBuffer,
2092 VkQueryPool queryPool,
2093 uint32_t startQuery,
2094 uint32_t queryCount)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002095{
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06002096 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05002097 VkDeviceMemory mem = get_mem_binding_from_object(queryPool);
2098 if (VK_FALSE == update_cmd_buf_and_mem_references(cmdBuffer, mem)) {
Tobin Ehlis62086412014-11-19 16:19:28 -07002099 char str[1024];
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002100 sprintf(str, "In vkCmdResetQueryPool() call unable to update binding of queryPool buffer %p to cmdBuffer %p", queryPool, cmdBuffer);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002101 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
Tobin Ehlis62086412014-11-19 16:19:28 -07002102 }
Mark Lobodzinski0c0d6a02015-03-02 20:23:52 -06002103 loader_platform_thread_unlock_mutex(&globalLock);
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002104 device_dispatch_table(cmdBuffer)->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002105}
2106
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002107VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
2108 VkInstance instance,
2109 VkFlags msgFlags,
2110 const PFN_vkDbgMsgCallback pfnMsgCallback,
2111 void* pUserData,
2112 VkDbgMsgCallback* pMsgCallback)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002113{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002114 return layer_create_msg_callback(instance, instance_dispatch_table(instance), msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002115}
2116
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002117VK_LAYER_EXPORT VkResult VKAPI vkDbgDestroyMsgCallback(
2118 VkInstance instance,
2119 VkDbgMsgCallback msgCallback)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002120{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002121 return layer_destroy_msg_callback(instance, instance_dispatch_table(instance), msgCallback);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002122}
2123
Mark Lobodzinskia908b162015-04-21 15:33:04 -06002124VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapChainWSI(
2125 VkDevice device,
2126 const VkSwapChainCreateInfoWSI *pCreateInfo,
2127 VkSwapChainWSI *pSwapChain)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002128{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002129 VkResult result = device_dispatch_table(device)->CreateSwapChainWSI(device, pCreateInfo, pSwapChain);
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002130
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002131 if (VK_SUCCESS == result) {
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002132 loader_platform_thread_lock_mutex(&globalLock);
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05002133 add_swap_chain_info(*pSwapChain);
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002134 loader_platform_thread_unlock_mutex(&globalLock);
Tobin Ehlis62086412014-11-19 16:19:28 -07002135 }
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002136
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002137 return result;
2138}
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05002139
Mark Lobodzinskia908b162015-04-21 15:33:04 -06002140VK_LAYER_EXPORT VkResult VKAPI vkDestroySwapChainWSI(
2141 VkSwapChainWSI swapChain)
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05002142{
2143 loader_platform_thread_lock_mutex(&globalLock);
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002144
2145 if (swapChainMap.find(swapChain) != swapChainMap.end()) {
2146 MT_SWAP_CHAIN_INFO* pInfo = swapChainMap[swapChain];
2147
David Pinedof5997ab2015-04-27 16:36:17 -06002148 if (pInfo->images.size() > 0) {
2149 for (std::vector<VkSwapChainImageInfoWSI>::const_iterator it = pInfo->images.begin();
2150 it != pInfo->images.end(); it++) {
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05002151 clear_object_binding(it->image);
David Pinedof5997ab2015-04-27 16:36:17 -06002152 freeMemObjInfo(it->memory, true);
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002153
David Pinedof5997ab2015-04-27 16:36:17 -06002154 objectMap.erase(it->image);
2155 }
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002156 }
2157
2158 delete pInfo;
2159 swapChainMap.erase(swapChain);
2160 }
2161
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05002162 loader_platform_thread_unlock_mutex(&globalLock);
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002163
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002164 return device_dispatch_table(swapChain)->DestroySwapChainWSI(swapChain);
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002165}
2166
Mark Lobodzinskia908b162015-04-21 15:33:04 -06002167VK_LAYER_EXPORT VkResult VKAPI vkGetSwapChainInfoWSI(
2168 VkSwapChainWSI swapChain,
2169 VkSwapChainInfoTypeWSI infoType,
2170 size_t *pDataSize,
2171 void *pData)
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002172{
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002173 VkResult result = device_dispatch_table(swapChain)->GetSwapChainInfoWSI(swapChain, infoType, pDataSize, pData);
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002174
2175 if (infoType == VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI && result == VK_SUCCESS) {
2176 const size_t count = *pDataSize / sizeof(VkSwapChainImageInfoWSI);
2177 MT_SWAP_CHAIN_INFO *pInfo = swapChainMap[swapChain];
2178
2179 if (pInfo->images.empty()) {
2180 pInfo->images.resize(count);
2181 memcpy(&pInfo->images[0], pData, sizeof(pInfo->images[0]) * count);
2182
David Pinedof5997ab2015-04-27 16:36:17 -06002183 if (pInfo->images.size() > 0) {
2184 for (std::vector<VkSwapChainImageInfoWSI>::const_iterator it = pInfo->images.begin();
2185 it != pInfo->images.end(); it++) {
2186 // Add image object, then insert the new Mem Object and then bind it to created image
Mark Lobodzinskic66c6712015-06-05 13:59:04 -05002187 add_object_info(it->image, VK_STRUCTURE_TYPE_MAX_ENUM, &pInfo->createInfo, sizeof(pInfo->createInfo), "persistent_image");
2188 add_mem_obj_info(it->memory, NULL);
2189 if (VK_FALSE == set_object_binding(it->image, it->memory)) {
David Pinedof5997ab2015-04-27 16:36:17 -06002190 char str[1024];
2191 sprintf(str, "In vkGetSwapChainInfoWSI(), unable to set image %p binding to mem obj %p", (void*)it->image, (void*)it->memory);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002192 layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, it->image, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
David Pinedof5997ab2015-04-27 16:36:17 -06002193 }
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002194 }
2195 }
2196 } else {
2197 const bool mismatch = (pInfo->images.size() != count ||
2198 memcmp(&pInfo->images[0], pData, sizeof(pInfo->images[0]) * count));
2199
2200 if (mismatch) {
2201 char str[1024];
2202 sprintf(str, "vkGetSwapChainInfoWSI(%p, VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI) returned mismatching data", swapChain);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -06002203 layerCbMsg(VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_SWAP_CHAIN_WSI, (VkObject) swapChain, 0, MEMTRACK_NONE, "SWAP_CHAIN", str);
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002204 }
2205 }
2206 }
2207
Mark Lobodzinski4aad3642015-03-17 10:53:12 -05002208 return result;
2209}
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002210
Jon Ashburn1245cec2015-05-18 13:20:15 -06002211VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(
2212 VkDevice dev,
Mark Lobodzinskia908b162015-04-21 15:33:04 -06002213 const char *funcName)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002214{
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -06002215 void *fptr;
2216
Jon Ashburn1245cec2015-05-18 13:20:15 -06002217 if (dev == NULL) {
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002218 return NULL;
Mark Lobodzinskia908b162015-04-21 15:33:04 -06002219 }
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002220
Ian Elliott81ac44c2015-01-13 17:52:38 -07002221 loader_platform_thread_once(&g_initOnce, initMemTracker);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002222
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002223 /* loader uses this to force layer initialization; device object is wrapped */
2224 if (!strcmp(funcName, "vkGetDeviceProcAddr")) {
2225 initDeviceTable((const VkBaseLayerObject *) dev);
Jon Ashburn1245cec2015-05-18 13:20:15 -06002226 return (void *) vkGetDeviceProcAddr;
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002227 }
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002228 if (!strcmp(funcName, "vkDestroyDevice"))
2229 return (void*) vkDestroyDevice;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002230 if (!strcmp(funcName, "vkQueueSubmit"))
2231 return (void*) vkQueueSubmit;
2232 if (!strcmp(funcName, "vkAllocMemory"))
2233 return (void*) vkAllocMemory;
2234 if (!strcmp(funcName, "vkFreeMemory"))
2235 return (void*) vkFreeMemory;
2236 if (!strcmp(funcName, "vkSetMemoryPriority"))
2237 return (void*) vkSetMemoryPriority;
2238 if (!strcmp(funcName, "vkMapMemory"))
2239 return (void*) vkMapMemory;
2240 if (!strcmp(funcName, "vkUnmapMemory"))
2241 return (void*) vkUnmapMemory;
2242 if (!strcmp(funcName, "vkPinSystemMemory"))
2243 return (void*) vkPinSystemMemory;
2244 if (!strcmp(funcName, "vkOpenSharedMemory"))
2245 return (void*) vkOpenSharedMemory;
2246 if (!strcmp(funcName, "vkOpenPeerMemory"))
2247 return (void*) vkOpenPeerMemory;
2248 if (!strcmp(funcName, "vkOpenPeerImage"))
2249 return (void*) vkOpenPeerImage;
2250 if (!strcmp(funcName, "vkDestroyObject"))
2251 return (void*) vkDestroyObject;
2252 if (!strcmp(funcName, "vkGetObjectInfo"))
2253 return (void*) vkGetObjectInfo;
Mark Lobodzinskifb9f5642015-05-11 17:21:15 -05002254 if (!strcmp(funcName, "vkBindObjectMemory"))
2255 return (void*) vkBindObjectMemory;
2256 if (!strcmp(funcName, "vkQueueBindSparseBufferMemory"))
2257 return (void*) vkQueueBindSparseBufferMemory;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002258 if (!strcmp(funcName, "vkCreateFence"))
2259 return (void*) vkCreateFence;
2260 if (!strcmp(funcName, "vkGetFenceStatus"))
2261 return (void*) vkGetFenceStatus;
2262 if (!strcmp(funcName, "vkResetFences"))
2263 return (void*) vkResetFences;
2264 if (!strcmp(funcName, "vkWaitForFences"))
2265 return (void*) vkWaitForFences;
2266 if (!strcmp(funcName, "vkQueueWaitIdle"))
2267 return (void*) vkQueueWaitIdle;
2268 if (!strcmp(funcName, "vkDeviceWaitIdle"))
2269 return (void*) vkDeviceWaitIdle;
2270 if (!strcmp(funcName, "vkCreateEvent"))
2271 return (void*) vkCreateEvent;
2272 if (!strcmp(funcName, "vkCreateQueryPool"))
2273 return (void*) vkCreateQueryPool;
2274 if (!strcmp(funcName, "vkCreateBuffer"))
2275 return (void*) vkCreateBuffer;
2276 if (!strcmp(funcName, "vkCreateBufferView"))
2277 return (void*) vkCreateBufferView;
2278 if (!strcmp(funcName, "vkCreateImage"))
2279 return (void*) vkCreateImage;
2280 if (!strcmp(funcName, "vkCreateImageView"))
2281 return (void*) vkCreateImageView;
2282 if (!strcmp(funcName, "vkCreateColorAttachmentView"))
2283 return (void*) vkCreateColorAttachmentView;
2284 if (!strcmp(funcName, "vkCreateDepthStencilView"))
2285 return (void*) vkCreateDepthStencilView;
2286 if (!strcmp(funcName, "vkCreateShader"))
2287 return (void*) vkCreateShader;
2288 if (!strcmp(funcName, "vkCreateGraphicsPipeline"))
2289 return (void*) vkCreateGraphicsPipeline;
2290 if (!strcmp(funcName, "vkCreateGraphicsPipelineDerivative"))
2291 return (void*) vkCreateGraphicsPipelineDerivative;
2292 if (!strcmp(funcName, "vkCreateComputePipeline"))
2293 return (void*) vkCreateComputePipeline;
2294 if (!strcmp(funcName, "vkCreateSampler"))
2295 return (void*) vkCreateSampler;
2296 if (!strcmp(funcName, "vkCreateDynamicViewportState"))
2297 return (void*) vkCreateDynamicViewportState;
2298 if (!strcmp(funcName, "vkCreateDynamicRasterState"))
2299 return (void*) vkCreateDynamicRasterState;
2300 if (!strcmp(funcName, "vkCreateDynamicColorBlendState"))
2301 return (void*) vkCreateDynamicColorBlendState;
2302 if (!strcmp(funcName, "vkCreateDynamicDepthStencilState"))
2303 return (void*) vkCreateDynamicDepthStencilState;
2304 if (!strcmp(funcName, "vkCreateCommandBuffer"))
2305 return (void*) vkCreateCommandBuffer;
2306 if (!strcmp(funcName, "vkBeginCommandBuffer"))
2307 return (void*) vkBeginCommandBuffer;
2308 if (!strcmp(funcName, "vkEndCommandBuffer"))
2309 return (void*) vkEndCommandBuffer;
2310 if (!strcmp(funcName, "vkResetCommandBuffer"))
2311 return (void*) vkResetCommandBuffer;
2312 if (!strcmp(funcName, "vkCmdBindPipeline"))
2313 return (void*) vkCmdBindPipeline;
2314 if (!strcmp(funcName, "vkCmdBindDynamicStateObject"))
2315 return (void*) vkCmdBindDynamicStateObject;
2316 if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
2317 return (void*) vkCmdBindDescriptorSets;
Courtney Goeltzenleuchter46962942015-04-16 13:38:46 -06002318 if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
2319 return (void*) vkCmdBindVertexBuffers;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002320 if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
2321 return (void*) vkCmdBindIndexBuffer;
2322 if (!strcmp(funcName, "vkCmdDrawIndirect"))
2323 return (void*) vkCmdDrawIndirect;
2324 if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
2325 return (void*) vkCmdDrawIndexedIndirect;
2326 if (!strcmp(funcName, "vkCmdDispatchIndirect"))
2327 return (void*) vkCmdDispatchIndirect;
2328 if (!strcmp(funcName, "vkCmdCopyBuffer"))
2329 return (void*) vkCmdCopyBuffer;
2330 if (!strcmp(funcName, "vkCmdCopyImage"))
2331 return (void*) vkCmdCopyImage;
2332 if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
2333 return (void*) vkCmdCopyBufferToImage;
2334 if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
2335 return (void*) vkCmdCopyImageToBuffer;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002336 if (!strcmp(funcName, "vkCmdUpdateBuffer"))
2337 return (void*) vkCmdUpdateBuffer;
2338 if (!strcmp(funcName, "vkCmdFillBuffer"))
2339 return (void*) vkCmdFillBuffer;
2340 if (!strcmp(funcName, "vkCmdClearColorImage"))
2341 return (void*) vkCmdClearColorImage;
2342 if (!strcmp(funcName, "vkCmdClearDepthStencil"))
2343 return (void*) vkCmdClearDepthStencil;
2344 if (!strcmp(funcName, "vkCmdResolveImage"))
2345 return (void*) vkCmdResolveImage;
2346 if (!strcmp(funcName, "vkCmdBeginQuery"))
2347 return (void*) vkCmdBeginQuery;
2348 if (!strcmp(funcName, "vkCmdEndQuery"))
2349 return (void*) vkCmdEndQuery;
2350 if (!strcmp(funcName, "vkCmdResetQueryPool"))
2351 return (void*) vkCmdResetQueryPool;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002352 if (!strcmp(funcName, "vkGetDeviceQueue"))
2353 return (void*) vkGetDeviceQueue;
Chia-I Wu5b66aa52015-04-16 22:02:10 +08002354 if (!strcmp(funcName, "vkCreateSwapChainWSI"))
2355 return (void*) vkCreateSwapChainWSI;
2356 if (!strcmp(funcName, "vkDestroySwapChainWSI"))
2357 return (void*) vkDestroySwapChainWSI;
2358 if (!strcmp(funcName, "vkGetSwapChainInfoWSI"))
2359 return (void*) vkGetSwapChainInfoWSI;
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -06002360
2361 fptr = msg_callback_get_proc_addr(funcName);
2362 if (fptr)
2363 return fptr;
2364
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002365 {
2366 VkLayerDispatchTable **ppDisp = (VkLayerDispatchTable **) dev;
2367 VkLayerDispatchTable* pTable = tableMap[*ppDisp];
2368 if (pTable->GetDeviceProcAddr == NULL)
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002369 return NULL;
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002370 return pTable->GetDeviceProcAddr(dev, funcName);
Jon Ashburn79b78ac2015-05-05 14:22:52 -06002371 }
2372}
2373
2374VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(
2375 VkInstance instance,
2376 const char *funcName)
2377{
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -06002378 void *fptr;
Jon Ashburn79b78ac2015-05-05 14:22:52 -06002379 if (instance == NULL) {
2380 return NULL;
2381 }
Jon Ashburnd9564002015-05-07 10:27:37 -06002382
Jon Ashburnd9564002015-05-07 10:27:37 -06002383 loader_platform_thread_once(&g_initOnce, initMemTracker);
Jon Ashburn79b78ac2015-05-05 14:22:52 -06002384
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002385 /* loader uses this to force layer initialization; instance object is wrapped */
2386 if (!strcmp(funcName, "vkGetInstanceProcAddr")) {
2387 initInstanceTable((const VkBaseLayerObject *) instance);
Jon Ashburn79b78ac2015-05-05 14:22:52 -06002388 return (void *) vkGetInstanceProcAddr;
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002389 }
2390
Mark Lobodzinski5176d3d2015-05-20 16:16:37 -05002391 if (!strcmp(funcName, "vkDestroyInstance"))
2392 return (void *) vkDestroyInstance;
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -06002393 if (!strcmp(funcName, "vkCreateInstance"))
2394 return (void*) vkCreateInstance;
Jon Ashburn79b78ac2015-05-05 14:22:52 -06002395 if (!strcmp(funcName, "vkCreateDevice"))
2396 return (void*) vkCreateDevice;
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -06002397
2398 fptr = msg_callback_get_proc_addr(funcName);
2399 if (fptr)
2400 return fptr;
2401
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002402 {
2403 VkLayerInstanceDispatchTable **ppDisp = (VkLayerInstanceDispatchTable **) instance;
2404 VkLayerInstanceDispatchTable* pTable = tableInstanceMap[*ppDisp];
2405 if (pTable->GetInstanceProcAddr == NULL)
Jon Ashburn79b78ac2015-05-05 14:22:52 -06002406 return NULL;
Jon Ashburn4f2575f2015-05-28 16:25:02 -06002407 return pTable->GetInstanceProcAddr(instance, funcName);
Tobin Ehlis791a49c2014-11-10 12:29:12 -07002408 }
2409}