blob: ca957fbbc56d894e56caacd93befbb7860c67e94 [file] [log] [blame]
Tobin Ehlisacab8882014-11-14 13:01:02 -07001/*
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -06002 * Vulkan
Tobin Ehlisacab8882014-11-14 13:01:02 -07003 *
4 * Copyright (C) 2014 LunarG, Inc.
5 *
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
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * 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
Tobin Ehlis2d1d9702015-07-03 09:42:57 -060025#include "vk_layer.h"
Courtney Goeltzenleuchter8b0e68d2015-07-05 22:13:43 -060026#include "vk_layer_extension_utils.h"
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -060027#include "vk_enum_string_helper.h"
Mark Lobodzinski14305ad2015-06-23 11:35:12 -060028
Tobin Ehlis3c26a542014-11-18 11:28:33 -070029// Object Tracker ERROR codes
30typedef enum _OBJECT_TRACK_ERROR
31{
Chia-I Wub1466182015-01-05 14:33:42 +080032 OBJTRACK_NONE, // Used for INFO & other non-error messages
33 OBJTRACK_UNKNOWN_OBJECT, // Updating uses of object that's not in global object list
34 OBJTRACK_INTERNAL_ERROR, // Bug with data tracking within the layer
35 OBJTRACK_DESTROY_OBJECT_FAILED, // Couldn't find object to be destroyed
Chia-I Wub1466182015-01-05 14:33:42 +080036 OBJTRACK_OBJECT_LEAK, // OBJECT was not correctly freed/destroyed
37 OBJTRACK_OBJCOUNT_MAX_EXCEEDED, // Request for Object data in excess of max obj count
Tobin Ehlis235c20e2015-01-16 08:56:30 -070038 OBJTRACK_INVALID_FENCE, // Requested status of unsubmitted fence object
Tobin Ehlis586aa012015-06-08 17:36:28 -060039 OBJTRACK_INVALID_OBJECT, // Object used that has never been created
Tobin Ehlis3c26a542014-11-18 11:28:33 -070040} OBJECT_TRACK_ERROR;
41
Tobin Ehlis235c20e2015-01-16 08:56:30 -070042// Object Status -- used to track state of individual objects
Mark Lobodzinski7d2d5ac2015-05-20 17:33:47 -050043typedef VkFlags ObjectStatusFlags;
44typedef enum _ObjectStatusFlagBits
Tobin Ehlis235c20e2015-01-16 08:56:30 -070045{
Mark Lobodzinski01552702015-02-03 10:06:31 -060046 OBJSTATUS_NONE = 0x00000000, // No status is set
47 OBJSTATUS_FENCE_IS_SUBMITTED = 0x00000001, // Fence has been submitted
48 OBJSTATUS_VIEWPORT_BOUND = 0x00000002, // Viewport state object has been bound
49 OBJSTATUS_RASTER_BOUND = 0x00000004, // Viewport state object has been bound
50 OBJSTATUS_COLOR_BLEND_BOUND = 0x00000008, // Viewport state object has been bound
51 OBJSTATUS_DEPTH_STENCIL_BOUND = 0x00000010, // Viewport state object has been bound
Mark Lobodzinski4186e712015-02-03 11:52:26 -060052 OBJSTATUS_GPU_MEM_MAPPED = 0x00000020, // Memory object is currently mapped
Mark Lobodzinski7d2d5ac2015-05-20 17:33:47 -050053} ObjectStatusFlagBits;
Chia-I Wu5b66aa52015-04-16 22:02:10 +080054
Tobin Ehlisacab8882014-11-14 13:01:02 -070055typedef struct _OBJTRACK_NODE {
Tony Barbour2a199c12015-07-09 17:31:46 -060056 uint64_t vkObj;
57 VkDbgObjectType objType;
58 ObjectStatusFlags status;
Tobin Ehlisacab8882014-11-14 13:01:02 -070059} OBJTRACK_NODE;
Mark Lobodzinskie1d3f0c2015-02-09 10:20:53 -060060
Tobin Ehlisacab8882014-11-14 13:01:02 -070061// prototype for extension functions
Mark Lobodzinski14305ad2015-06-23 11:35:12 -060062uint64_t objTrackGetObjectCount(VkDevice device);
Tony Barbour2a199c12015-07-09 17:31:46 -060063uint64_t objTrackGetObjectsOfTypeCount(VkDevice, VkDbgObjectType type);
Mark Lobodzinskie1d3f0c2015-02-09 10:20:53 -060064
Tobin Ehlis3c26a542014-11-18 11:28:33 -070065// Func ptr typedefs
Mark Lobodzinski14305ad2015-06-23 11:35:12 -060066typedef uint64_t (*OBJ_TRACK_GET_OBJECT_COUNT)(VkDevice);
Tony Barbour2a199c12015-07-09 17:31:46 -060067typedef uint64_t (*OBJ_TRACK_GET_OBJECTS_OF_TYPE_COUNT)(VkDevice, VkDbgObjectType);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -060068
69typedef struct _layer_data {
70 debug_report_data *report_data;
71 //TODO: put instance data here
72 VkDbgMsgCallback logging_callback;
Ian Elliottb134e842015-07-06 14:31:32 -060073 bool wsi_enabled;
Courtney Goeltzenleuchter8b0e68d2015-07-05 22:13:43 -060074 bool objtrack_extensions_enabled;
Mark Lobodzinski14305ad2015-06-23 11:35:12 -060075} layer_data;
76
77static std::unordered_map<void*, layer_data *> layer_data_map;
78static device_table_map ObjectTracker_device_table_map;
79static instance_table_map ObjectTracker_instance_table_map;
80
81static long long unsigned int object_track_index = 0;
82static int objLockInitialized = 0;
83static loader_platform_thread_mutex objLock;
84
85// Objects stored in a global map w/ struct containing basic info
Tony Barbour2a199c12015-07-09 17:31:46 -060086// unordered_map<const void*, OBJTRACK_NODE*> objMap;
Mark Lobodzinski14305ad2015-06-23 11:35:12 -060087
Tony Barbour2a199c12015-07-09 17:31:46 -060088#define NUM_OBJECT_TYPES VK_OBJECT_TYPE_NUM
Mark Lobodzinski14305ad2015-06-23 11:35:12 -060089
90static uint64_t numObjs[NUM_OBJECT_TYPES] = {0};
91static uint64_t numTotalObjs = 0;
Cody Northropef72e2a2015-08-03 17:04:53 -060092static VkQueueFamilyProperties *queueInfo = NULL;
Mark Lobodzinski14305ad2015-06-23 11:35:12 -060093static uint32_t queueCount = 0;
94
95template layer_data *get_my_data_ptr<layer_data>(
96 void *data_key, std::unordered_map<void *, layer_data *> &data_map);
97
Mark Lobodzinskif993d542015-09-01 08:52:55 -060098static inline const char* string_VkDbgObjectType(VkDbgObjectType input_value)
99{
100 switch ((VkDbgObjectType)input_value)
101 {
102 case VK_OBJECT_TYPE_CMD_POOL:
103 return "VK_OBJECT_TYPE_CMD_POOL";
104 case VK_OBJECT_TYPE_BUFFER:
105 return "VK_OBJECT_TYPE_BUFFER";
106 case VK_OBJECT_TYPE_BUFFER_VIEW:
107 return "VK_OBJECT_TYPE_BUFFER_VIEW";
108 case VK_OBJECT_TYPE_ATTACHMENT_VIEW:
109 return "VK_OBJECT_TYPE_ATTACHMENT_VIEW";
110 case VK_OBJECT_TYPE_COMMAND_BUFFER:
111 return "VK_OBJECT_TYPE_COMMAND_BUFFER";
112 case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
113 return "VK_OBJECT_TYPE_DESCRIPTOR_POOL";
114 case VK_OBJECT_TYPE_DESCRIPTOR_SET:
115 return "VK_OBJECT_TYPE_DESCRIPTOR_SET";
116 case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
117 return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT";
118 case VK_OBJECT_TYPE_DEVICE:
119 return "VK_OBJECT_TYPE_DEVICE";
120 case VK_OBJECT_TYPE_DEVICE_MEMORY:
121 return "VK_OBJECT_TYPE_DEVICE_MEMORY";
122 case VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE:
123 return "VK_OBJECT_TYPE_DYNAMIC_BLEND_STATE";
124 case VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE:
125 return "VK_OBJECT_TYPE_DYNAMIC_DEPTH_BOUNDS_STATE";
126 case VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE:
127 return "VK_OBJECT_TYPE_DYNAMIC_STENCIL_STATE";
128 case VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE:
129 return "VK_OBJECT_TYPE_DYNAMIC_LINE_WIDTH_STATE";
130 case VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE:
131 return "VK_OBJECT_TYPE_DYNAMIC_DEPTH_BIAS_STATE";
132 case VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE:
133 return "VK_OBJECT_TYPE_DYNAMIC_VIEPORT_STATE";
134 case VK_OBJECT_TYPE_EVENT:
135 return "VK_OBJECT_TYPE_EVENT";
136 case VK_OBJECT_TYPE_FENCE:
137 return "VK_OBJECT_TYPE_FENCE";
138 case VK_OBJECT_TYPE_FRAMEBUFFER:
139 return "VK_OBJECT_TYPE_FRAMEBUFFER";
140 case VK_OBJECT_TYPE_IMAGE:
141 return "VK_OBJECT_TYPE_IMAGE";
142 case VK_OBJECT_TYPE_IMAGE_VIEW:
143 return "VK_OBJECT_TYPE_IMAGE_VIEW";
144 case VK_OBJECT_TYPE_INSTANCE:
145 return "VK_OBJECT_TYPE_INSTANCE";
146 case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
147 return "VK_OBJECT_TYPE_PHYSICAL_DEVICE";
148 case VK_OBJECT_TYPE_PIPELINE:
149 return "VK_OBJECT_TYPE_PIPELINE";
150 case VK_OBJECT_TYPE_PIPELINE_LAYOUT:
151 return "VK_OBJECT_TYPE_PIPELINE_LAYOUT";
152 case VK_OBJECT_TYPE_PIPELINE_CACHE:
153 return "VK_OBJECT_TYPE_PIPELINE_CACHE";
154 case VK_OBJECT_TYPE_QUERY_POOL:
155 return "VK_OBJECT_TYPE_QUERY_POOL";
156 case VK_OBJECT_TYPE_QUEUE:
157 return "VK_OBJECT_TYPE_QUEUE";
158 case VK_OBJECT_TYPE_RENDER_PASS:
159 return "VK_OBJECT_TYPE_RENDER_PASS";
160 case VK_OBJECT_TYPE_SAMPLER:
161 return "VK_OBJECT_TYPE_SAMPLER";
162 case VK_OBJECT_TYPE_SEMAPHORE:
163 return "VK_OBJECT_TYPE_SEMAPHORE";
164 case VK_OBJECT_TYPE_SHADER:
165 return "VK_OBJECT_TYPE_SHADER";
166 case VK_OBJECT_TYPE_SHADER_MODULE:
167 return "VK_OBJECT_TYPE_SHADER_MODULE";
Ian Elliott338dedb2015-08-21 15:09:33 -0600168 case VK_OBJECT_TYPE_SWAPCHAIN_KHR:
169 return "VK_OBJECT_TYPE_SWAPCHAIN_KHR";
Mark Lobodzinskif993d542015-09-01 08:52:55 -0600170 default:
171 return "Unhandled VkObjectType";
172 }
173}
174
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600175//
176// Internal Object Tracker Functions
177//
178
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600179static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo, VkDevice device)
180{
Courtney Goeltzenleuchter8b0e68d2015-07-05 22:13:43 -0600181 layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
Ian Elliottb134e842015-07-06 14:31:32 -0600182 my_device_data->wsi_enabled = false;
Courtney Goeltzenleuchter8b0e68d2015-07-05 22:13:43 -0600183 for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
Ian Elliott338dedb2015-08-21 15:09:33 -0600184 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
Ian Elliottb134e842015-07-06 14:31:32 -0600185 my_device_data->wsi_enabled = true;
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600186
Courtney Goeltzenleuchter8b0e68d2015-07-05 22:13:43 -0600187 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], "OBJTRACK_EXTENSIONS") == 0)
188 my_device_data->objtrack_extensions_enabled = true;
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600189 }
190}
191
192// Indicate device or instance dispatch table type
193typedef enum _DispTableType
194{
195 DISP_TBL_TYPE_INSTANCE,
196 DISP_TBL_TYPE_DEVICE,
197} DispTableType;
198
Tony Barbour2a199c12015-07-09 17:31:46 -0600199debug_report_data *mdd(const void* object)
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600200{
201 dispatch_key key = get_dispatch_key(object);
202 layer_data *my_data = get_my_data_ptr(key, layer_data_map);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600203 return my_data->report_data;
204}
205
206debug_report_data *mid(VkInstance object)
207{
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600208 dispatch_key key = get_dispatch_key(object);
209 layer_data *my_data = get_my_data_ptr(key, layer_data_map);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600210 return my_data->report_data;
211}
212
213// For each Queue's doubly linked-list of mem refs
214typedef struct _OT_MEM_INFO {
215 VkDeviceMemory mem;
216 struct _OT_MEM_INFO *pNextMI;
217 struct _OT_MEM_INFO *pPrevMI;
218
219} OT_MEM_INFO;
220
221// Track Queue information
222typedef struct _OT_QUEUE_INFO {
223 OT_MEM_INFO *pMemRefList;
224 struct _OT_QUEUE_INFO *pNextQI;
225 uint32_t queueNodeIndex;
226 VkQueue queue;
227 uint32_t refCount;
228} OT_QUEUE_INFO;
229
230// Global list of QueueInfo structures, one per queue
231static OT_QUEUE_INFO *g_pQueueInfo = NULL;
232
233// Convert an object type enum to an object type array index
234static uint32_t
235objTypeToIndex(
236 uint32_t objType)
237{
238 uint32_t index = objType;
239 if (objType > VK_OBJECT_TYPE_END_RANGE) {
Ian Elliott338dedb2015-08-21 15:09:33 -0600240 // These come from vk_ext_khr_swapchain.h, rebase
241 index = (index -(VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NUMBER * -1000)) + VK_OBJECT_TYPE_END_RANGE;
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600242 }
243 return index;
244}
245
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600246// Add new queue to head of global queue list
247static void
248addQueueInfo(
249 uint32_t queueNodeIndex,
250 VkQueue queue)
251{
252 OT_QUEUE_INFO *pQueueInfo = new OT_QUEUE_INFO;
253
254 if (pQueueInfo != NULL) {
255 memset(pQueueInfo, 0, sizeof(OT_QUEUE_INFO));
256 pQueueInfo->queue = queue;
257 pQueueInfo->queueNodeIndex = queueNodeIndex;
258 pQueueInfo->pNextQI = g_pQueueInfo;
259 g_pQueueInfo = pQueueInfo;
260 }
261 else {
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -0600262 log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, reinterpret_cast<uint64_t>(queue), 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK",
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600263 "ERROR: VK_ERROR_OUT_OF_HOST_MEMORY -- could not allocate memory for Queue Information");
264 }
265}
266
267// Destroy memRef lists and free all memory
268static void
269destroyQueueMemRefLists(void)
270{
271 OT_QUEUE_INFO *pQueueInfo = g_pQueueInfo;
272 OT_QUEUE_INFO *pDelQueueInfo = NULL;
273 while (pQueueInfo != NULL) {
274 OT_MEM_INFO *pMemInfo = pQueueInfo->pMemRefList;
275 while (pMemInfo != NULL) {
276 OT_MEM_INFO *pDelMemInfo = pMemInfo;
277 pMemInfo = pMemInfo->pNextMI;
278 delete pDelMemInfo;
279 }
280 pDelQueueInfo = pQueueInfo;
281 pQueueInfo = pQueueInfo->pNextQI;
282 delete pDelQueueInfo;
283 }
284 g_pQueueInfo = pQueueInfo;
285}
286
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600287static void
288setGpuQueueInfoState(
Tony Barbour426b9052015-06-24 16:06:58 -0600289 uint32_t count,
290 void *pData)
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600291{
Tony Barbour426b9052015-06-24 16:06:58 -0600292 queueCount = count;
Cody Northropef72e2a2015-08-03 17:04:53 -0600293 queueInfo = (VkQueueFamilyProperties*)realloc((void*)queueInfo, count * sizeof(VkQueueFamilyProperties));
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600294 if (queueInfo != NULL) {
Cody Northropef72e2a2015-08-03 17:04:53 -0600295 memcpy(queueInfo, pData, count * sizeof(VkQueueFamilyProperties));
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600296 }
297}
298
299// Check Queue type flags for selected queue operations
300static void
301validateQueueFlags(
302 VkQueue queue,
303 const char *function)
304{
305 OT_QUEUE_INFO *pQueueInfo = g_pQueueInfo;
306 while ((pQueueInfo != NULL) && (pQueueInfo->queue != queue)) {
307 pQueueInfo = pQueueInfo->pNextQI;
308 }
309 if (pQueueInfo != NULL) {
310 if ((queueInfo != NULL) && (queueInfo[pQueueInfo->queueNodeIndex].queueFlags & VK_QUEUE_SPARSE_MEMMGR_BIT) == 0) {
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -0600311 log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, reinterpret_cast<uint64_t>(queue), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600312 "Attempting %s on a non-memory-management capable queue -- VK_QUEUE_SPARSE_MEMMGR_BIT not set", function);
313 } else {
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -0600314 log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, reinterpret_cast<uint64_t>(queue), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600315 "Attempting %s on a possibly non-memory-management capable queue -- VK_QUEUE_SPARSE_MEMMGR_BIT not known", function);
316 }
317 }
318}
319
Tony Barbour2a199c12015-07-09 17:31:46 -0600320/* TODO: Port to new type safety */
321#if 0
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600322// Check object status for selected flag state
Courtney Goeltzenleuchter1f41f542015-07-09 11:44:38 -0600323static VkBool32
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600324validate_status(
325 VkObject dispatchable_object,
326 VkObject vkObj,
327 VkObjectType objType,
328 ObjectStatusFlags status_mask,
329 ObjectStatusFlags status_flag,
330 VkFlags msg_flags,
331 OBJECT_TRACK_ERROR error_code,
332 const char *fail_msg)
333{
334 if (objMap.find(vkObj) != objMap.end()) {
335 OBJTRACK_NODE* pNode = objMap[vkObj];
336 if ((pNode->status & status_mask) != status_flag) {
337 char str[1024];
338 log_msg(mdd(dispatchable_object), msg_flags, pNode->objType, vkObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",
339 "OBJECT VALIDATION WARNING: %s object 0x%" PRIxLEAST64 ": %s", string_VkObjectType(objType),
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -0600340 reinterpret_cast<uint64_t>(vkObj), fail_msg);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600341 return VK_FALSE;
342 }
343 return VK_TRUE;
344 }
345 else {
346 // If we do not find it print an error
347 log_msg(mdd(dispatchable_object), msg_flags, (VkObjectType) 0, vkObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",
348 "Unable to obtain status for non-existent object 0x%" PRIxLEAST64 " of %s type",
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -0600349 reinterpret_cast<uint64_t>(vkObj), string_VkObjectType(objType));
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600350 return VK_FALSE;
351 }
352}
Tony Barbour2a199c12015-07-09 17:31:46 -0600353#endif
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600354
355#include "vk_dispatch_table_helper.h"
356static void
357initObjectTracker(
358 layer_data *my_data)
359{
360 uint32_t report_flags = 0;
361 uint32_t debug_action = 0;
362 FILE *log_output = NULL;
363 const char *option_str;
364 // initialize ObjectTracker options
365 report_flags = getLayerOptionFlags("ObjectTrackerReportFlags", 0);
366 getLayerOptionEnum("ObjectTrackerDebugAction", (uint32_t *) &debug_action);
367
368 if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG)
369 {
370 option_str = getLayerOption("ObjectTrackerLogFilename");
371 if (option_str) {
372 log_output = fopen(option_str, "w");
373 }
374 if (log_output == NULL) {
375 log_output = stdout;
376 }
377
378 layer_create_msg_callback(my_data->report_data, report_flags, log_callback, (void *) log_output, &my_data->logging_callback);
379 }
380
381 if (!objLockInitialized)
382 {
383 // TODO/TBD: Need to delete this mutex sometime. How??? One
384 // suggestion is to call this during vkCreateInstance(), and then we
385 // can clean it up during vkDestroyInstance(). However, that requires
386 // that the layer have per-instance locks. We need to come back and
387 // address this soon.
388 loader_platform_thread_create_mutex(&objLock);
389 objLockInitialized = 1;
390 }
391}
392
Tony Barbour2a199c12015-07-09 17:31:46 -0600393//
394// Forward declares of generated routines
395//
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600396
Tony Barbour2a199c12015-07-09 17:31:46 -0600397static void create_obj(VkInstance dispatchable_object, VkInstance object, VkDbgObjectType objType);
398static void create_obj(VkDevice dispatchable_object, VkDevice object, VkDbgObjectType objType);
399static void create_obj(VkDevice dispatchable_object, VkDescriptorSet object, VkDbgObjectType objType);
400static void validate_object(VkInstance dispatchable_object, VkInstance object);
401static void validate_object(VkDevice dispatchable_object, VkDevice object);
402static void validate_object(VkDevice dispatchable_object, VkDescriptorPool object);
403static void destroy_obj(VkInstance dispatchable_object, VkInstance object);
404static void destroy_obj(VkDevice dispatchable_object, VkDeviceMemory object);
Tony Barbour912e8152015-07-20 10:52:13 -0600405static void destroy_obj(VkDevice dispatchable_object, VkDescriptorSet object);
Tony Barbour2a199c12015-07-09 17:31:46 -0600406static void set_status(VkDevice dispatchable_object, VkDeviceMemory object, VkDbgObjectType objType, ObjectStatusFlags status_flag);
407static void reset_status(VkDevice dispatchable_object, VkDeviceMemory object, VkDbgObjectType objType, ObjectStatusFlags status_flag);
408#if 0
409static VkBool32 validate_status(VkDevice dispatchable_object, VkFence object, VkDbgObjectType objType,
410 ObjectStatusFlags status_mask, ObjectStatusFlags status_flag, VkFlags msg_flags, OBJECT_TRACK_ERROR error_code,
411 const char *fail_msg);
412#endif
413extern unordered_map<const void*, OBJTRACK_NODE*> VkBufferMap;
414extern unordered_map<const void*, OBJTRACK_NODE*> VkFenceMap;
415extern unordered_map<const void*, OBJTRACK_NODE*> VkSemaphoreMap;
416extern unordered_map<const void*, OBJTRACK_NODE*> VkCmdBufferMap;
Ian Elliott338dedb2015-08-21 15:09:33 -0600417extern unordered_map<const void*, OBJTRACK_NODE*> VkSwapchainKHRMap;
Tony Barbour2a199c12015-07-09 17:31:46 -0600418
419static void validate_object(VkQueue dispatchable_object, VkBuffer object)
420{
421 if (VkBufferMap.find((void*)object.handle) != VkBufferMap.end()) {
422 log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
Tony Barbour8db65372015-07-10 18:32:33 -0600423 "Invalid VkBuffer Object %p", object.handle);
Tony Barbour2a199c12015-07-09 17:31:46 -0600424 }
425}
426
427static void set_status(VkQueue dispatchable_object, VkFence object, VkDbgObjectType objType, ObjectStatusFlags status_flag)
428{
429 if (object != VK_NULL_HANDLE) {
430 if (VkFenceMap.find((void*)object.handle) != VkFenceMap.end()) {
431 OBJTRACK_NODE* pNode = VkFenceMap[(void*)object.handle];
432 pNode->status |= status_flag;
433 return;
434 }
435 else {
436 // If we do not find it print an error
Tony Barbour8db65372015-07-10 18:32:33 -0600437 log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",
Tony Barbour2a199c12015-07-09 17:31:46 -0600438 "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type",
Tony Barbour8db65372015-07-10 18:32:33 -0600439 object.handle, string_VkDbgObjectType(objType));
Tony Barbour2a199c12015-07-09 17:31:46 -0600440 }
441 }
442}
443
444static void validate_object(VkQueue dispatchable_object, VkSemaphore object)
445{
446 if (VkSemaphoreMap.find((void*)object.handle) == VkSemaphoreMap.end()) {
447 log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
Tony Barbour8db65372015-07-10 18:32:33 -0600448 "Invalid VkSemaphore Object %p", object.handle);
Tony Barbour2a199c12015-07-09 17:31:46 -0600449 }
450}
451
452static void validate_object(VkDevice dispatchable_object, VkCmdBuffer object)
453{
Tobin Ehlis33ce8fd2015-07-10 18:25:07 -0600454 if (VkCmdBufferMap.find(object) == VkCmdBufferMap.end()) {
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -0600455 log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
456 "Invalid VkCmdBuffer Object %p",reinterpret_cast<uint64_t>(object));
Tony Barbour2a199c12015-07-09 17:31:46 -0600457 }
458}
459
460static void create_obj(VkDevice dispatchable_object, VkCmdBuffer vkObj, VkDbgObjectType objType)
461{
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -0600462 log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast<uint64_t>(vkObj), 0, OBJTRACK_NONE, "OBJTRACK",
Tony Barbour2a199c12015-07-09 17:31:46 -0600463 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -0600464 reinterpret_cast<uint64_t>(vkObj));
Tony Barbour2a199c12015-07-09 17:31:46 -0600465
466 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;
467 pNewObjNode->objType = objType;
468 pNewObjNode->status = OBJSTATUS_NONE;
Courtney Goeltzenleuchter0f2b9e22015-08-26 15:09:25 -0600469 pNewObjNode->vkObj = reinterpret_cast<uint64_t>(vkObj);
Tony Barbour2a199c12015-07-09 17:31:46 -0600470 VkCmdBufferMap[vkObj] = pNewObjNode;
471 uint32_t objIndex = objTypeToIndex(objType);
472 numObjs[objIndex]++;
473 numTotalObjs++;
474}
Ian Elliott338dedb2015-08-21 15:09:33 -0600475static void create_obj(VkDevice dispatchable_object, VkSwapchainKHR vkObj, VkDbgObjectType objType)
Tony Barbour2a199c12015-07-09 17:31:46 -0600476{
Tony Barbour7910de72015-07-13 16:37:21 -0600477 log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, vkObj.handle, 0, OBJTRACK_NONE, "OBJTRACK",
Tony Barbour2a199c12015-07-09 17:31:46 -0600478 "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),
Tony Barbour7910de72015-07-13 16:37:21 -0600479 vkObj.handle);
Tony Barbour2a199c12015-07-09 17:31:46 -0600480
481 OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;
482 pNewObjNode->objType = objType;
483 pNewObjNode->status = OBJSTATUS_NONE;
Tony Barbour7910de72015-07-13 16:37:21 -0600484 pNewObjNode->vkObj = vkObj.handle;
Ian Elliott338dedb2015-08-21 15:09:33 -0600485 VkSwapchainKHRMap[(void*) vkObj.handle] = pNewObjNode;
Tony Barbour2a199c12015-07-09 17:31:46 -0600486 uint32_t objIndex = objTypeToIndex(objType);
487 numObjs[objIndex]++;
488 numTotalObjs++;
489}
Ian Elliott338dedb2015-08-21 15:09:33 -0600490static void destroy_obj(VkDevice dispatchable_object, VkSwapchainKHR object)
Tony Barbour2a199c12015-07-09 17:31:46 -0600491{
Ian Elliott338dedb2015-08-21 15:09:33 -0600492 if (VkSwapchainKHRMap.find((void*) object.handle) != VkSwapchainKHRMap.end()) {
493 OBJTRACK_NODE* pNode = VkSwapchainKHRMap[(void*) object.handle];
Tony Barbour2a199c12015-07-09 17:31:46 -0600494 uint32_t objIndex = objTypeToIndex(pNode->objType);
495 assert(numTotalObjs > 0);
496 numTotalObjs--;
497 assert(numObjs[objIndex] > 0);
498 numObjs[objIndex]--;
Tony Barbour7910de72015-07-13 16:37:21 -0600499 log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",
Tony Barbour2a199c12015-07-09 17:31:46 -0600500 "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%lu total objs remain & %lu %s objs).",
Tony Barbour7910de72015-07-13 16:37:21 -0600501 string_VkDbgObjectType(pNode->objType), object.handle, numTotalObjs, numObjs[objIndex],
Tony Barbour2a199c12015-07-09 17:31:46 -0600502 string_VkDbgObjectType(pNode->objType));
503 delete pNode;
Ian Elliott338dedb2015-08-21 15:09:33 -0600504 VkSwapchainKHRMap.erase((void*) object.handle);
Tony Barbour2a199c12015-07-09 17:31:46 -0600505 } else {
Tony Barbour7910de72015-07-13 16:37:21 -0600506 log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",
Tony Barbour2a199c12015-07-09 17:31:46 -0600507 "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",
Tony Barbour7910de72015-07-13 16:37:21 -0600508 object.handle);
Tony Barbour2a199c12015-07-09 17:31:46 -0600509 }
510}
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600511//
512// Non-auto-generated API functions called by generated code
513//
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600514VkResult
515explicit_CreateInstance(
516 const VkInstanceCreateInfo *pCreateInfo,
517 VkInstance * pInstance)
518{
David Pinedo565035c2015-07-31 10:46:25 -0600519
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600520 VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ObjectTracker_instance_table_map, *pInstance);
521 VkResult result = pInstanceTable->CreateInstance(pCreateInfo, pInstance);
522
523 if (result == VK_SUCCESS) {
524 layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
525 my_data->report_data = debug_report_create_instance(
Courtney Goeltzenleuchter8b0e68d2015-07-05 22:13:43 -0600526 pInstanceTable,
527 *pInstance,
528 pCreateInfo->extensionCount,
529 pCreateInfo->ppEnabledExtensionNames);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600530
531 initObjectTracker(my_data);
Tobin Ehlis86b52ec2015-06-30 14:31:50 -0600532 create_obj(*pInstance, *pInstance, VK_OBJECT_TYPE_INSTANCE);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600533 }
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600534 return result;
535}
536
537VkResult
Cody Northropef72e2a2015-08-03 17:04:53 -0600538explicit_GetPhysicalDeviceQueueFamilyProperties(
Tony Barbour426b9052015-06-24 16:06:58 -0600539 VkPhysicalDevice gpu,
Cody Northropef72e2a2015-08-03 17:04:53 -0600540 uint32_t* pCount,
541 VkQueueFamilyProperties* pProperties)
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600542{
Cody Northropef72e2a2015-08-03 17:04:53 -0600543 VkResult result = get_dispatch_table(ObjectTracker_instance_table_map, gpu)->GetPhysicalDeviceQueueFamilyProperties(gpu, pCount, pProperties);
Tony Barbour426b9052015-06-24 16:06:58 -0600544
545 loader_platform_thread_lock_mutex(&objLock);
Cody Northropef72e2a2015-08-03 17:04:53 -0600546 if (pProperties != NULL)
547 setGpuQueueInfoState(*pCount, pProperties);
Tony Barbour426b9052015-06-24 16:06:58 -0600548 loader_platform_thread_unlock_mutex(&objLock);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600549 return result;
550}
551
552VkResult
553explicit_CreateDevice(
554 VkPhysicalDevice gpu,
555 const VkDeviceCreateInfo *pCreateInfo,
556 VkDevice *pDevice)
557{
558 loader_platform_thread_lock_mutex(&objLock);
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -0600559// VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ObjectTracker_instance_table_map, gpu);
560 VkLayerDispatchTable *pDeviceTable = get_dispatch_table(ObjectTracker_device_table_map, *pDevice);
561 VkResult result = pDeviceTable->CreateDevice(gpu, pCreateInfo, pDevice);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600562 if (result == VK_SUCCESS) {
563 layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
564 //// VkLayerDispatchTable *pTable = get_dispatch_table(ObjectTracker_device_table_map, *pDevice);
565 layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
566 my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -0600567 create_obj(*pDevice, *pDevice, VK_OBJECT_TYPE_DEVICE);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600568 }
569
570 loader_platform_thread_unlock_mutex(&objLock);
571 return result;
572}
573
574VkResult
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600575explicit_GetDeviceQueue(
576 VkDevice device,
577 uint32_t queueNodeIndex,
578 uint32_t queueIndex,
579 VkQueue *pQueue)
580{
581 loader_platform_thread_lock_mutex(&objLock);
582 validate_object(device, device);
583 loader_platform_thread_unlock_mutex(&objLock);
584
585 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
586
587 loader_platform_thread_lock_mutex(&objLock);
588 addQueueInfo(queueNodeIndex, *pQueue);
589 loader_platform_thread_unlock_mutex(&objLock);
590
591 return result;
592}
593
594VkResult
595explicit_QueueSubmit(
596 VkQueue queue,
597 uint32_t cmdBufferCount,
598 const VkCmdBuffer *pCmdBuffers,
599 VkFence fence)
600{
601 loader_platform_thread_lock_mutex(&objLock);
602 set_status(queue, fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED);
603 // TODO: Fix for updated memory reference mechanism
604 // validate_memory_mapping_status(pMemRefs, memRefCount);
605 // validate_mem_ref_count(memRefCount);
606 loader_platform_thread_unlock_mutex(&objLock);
607
608 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, queue)->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
609
610 return result;
611}
612
613VkResult
614explicit_MapMemory(
615 VkDevice device,
616 VkDeviceMemory mem,
617 VkDeviceSize offset,
618 VkDeviceSize size,
619 VkFlags flags,
620 void **ppData)
621{
622 loader_platform_thread_lock_mutex(&objLock);
623 set_status(device, mem, VK_OBJECT_TYPE_DEVICE_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);
624 validate_object(device, device);
625 loader_platform_thread_unlock_mutex(&objLock);
626
627 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->MapMemory(device, mem, offset, size, flags, ppData);
628
629 return result;
630}
631
632VkResult
633explicit_UnmapMemory(
634 VkDevice device,
635 VkDeviceMemory mem)
636{
637 loader_platform_thread_lock_mutex(&objLock);
638 reset_status(device, mem, VK_OBJECT_TYPE_DEVICE_MEMORY, OBJSTATUS_GPU_MEM_MAPPED);
639 validate_object(device, device);
640 loader_platform_thread_unlock_mutex(&objLock);
641
642 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->UnmapMemory(device, mem);
643
644 return result;
645}
646
647VkResult
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600648explicit_QueueBindSparseBufferMemory(
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -0600649 VkQueue queue,
650 VkBuffer buffer,
651 uint32_t numBindings,
652 const VkSparseMemoryBindInfo* pBindInfo)
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600653{
654 loader_platform_thread_lock_mutex(&objLock);
655 validateQueueFlags(queue, "QueueBindSparseBufferMemory");
656 validate_object(queue, buffer);
657 loader_platform_thread_unlock_mutex(&objLock);
658
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -0600659 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, queue)->QueueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600660 return result;
661}
662
663VkResult
664explicit_QueueBindSparseImageMemory(
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -0600665 VkQueue queue,
666 VkImage image,
667 uint32_t numBindings,
668 const VkSparseImageMemoryBindInfo* pBindInfo)
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600669{
670 loader_platform_thread_lock_mutex(&objLock);
671 validateQueueFlags(queue, "QueueBindSparseImageMemory");
672 loader_platform_thread_unlock_mutex(&objLock);
673
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -0600674 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, queue)->QueueBindSparseImageMemory(queue, image, numBindings, pBindInfo);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600675 return result;
676}
677
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -0600678VkResult
679explicit_QueueBindSparseImageOpaqueMemory(
680 VkQueue queue,
681 VkImage image,
682 uint32_t numBindings,
683 const VkSparseMemoryBindInfo* pBindInfo)
684{
685 loader_platform_thread_lock_mutex(&objLock);
686 validateQueueFlags(queue, "QueueBindSparseImageOpaqueMemory");
687 loader_platform_thread_unlock_mutex(&objLock);
688
689 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, queue)->QueueBindSparseImageOpaqueMemory(queue, image, numBindings, pBindInfo);
690 return result;
691}
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600692
693VkResult
694explicit_GetFenceStatus(
695 VkDevice device,
696 VkFence fence)
697{
698 loader_platform_thread_lock_mutex(&objLock);
699 // Warn if submitted_flag is not set
Tony Barbour2a199c12015-07-09 17:31:46 -0600700#if 0
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600701 validate_status(device, fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED, OBJSTATUS_FENCE_IS_SUBMITTED,
702 VK_DBG_REPORT_ERROR_BIT, OBJTRACK_INVALID_FENCE, "Status Requested for Unsubmitted Fence");
Tony Barbour2a199c12015-07-09 17:31:46 -0600703#endif
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600704 validate_object(device, device);
705 loader_platform_thread_unlock_mutex(&objLock);
706
707 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->GetFenceStatus(device, fence);
708
709 return result;
710}
711
712VkResult
713explicit_WaitForFences(
714 VkDevice device,
715 uint32_t fenceCount,
716 const VkFence *pFences,
Courtney Goeltzenleuchter1f41f542015-07-09 11:44:38 -0600717 VkBool32 waitAll,
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600718 uint64_t timeout)
719{
720 loader_platform_thread_lock_mutex(&objLock);
Tony Barbour2a199c12015-07-09 17:31:46 -0600721#if 0
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600722 // Warn if waiting on unsubmitted fence
723 for (uint32_t i = 0; i < fenceCount; i++) {
724 validate_status(device, pFences[i], VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED, OBJSTATUS_FENCE_IS_SUBMITTED,
725 VK_DBG_REPORT_ERROR_BIT, OBJTRACK_INVALID_FENCE, "Waiting for Unsubmitted Fence");
726 }
Tony Barbour2a199c12015-07-09 17:31:46 -0600727#endif
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600728 validate_object(device, device);
729 loader_platform_thread_unlock_mutex(&objLock);
730
731 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
732
733 return result;
734}
735
736VkResult
737explicit_AllocDescriptorSets(
738 VkDevice device,
739 VkDescriptorPool descriptorPool,
740 VkDescriptorSetUsage setUsage,
741 uint32_t count,
742 const VkDescriptorSetLayout *pSetLayouts,
Cody Northropc8aa4a52015-08-03 12:47:29 -0600743 VkDescriptorSet *pDescriptorSets)
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600744{
745 loader_platform_thread_lock_mutex(&objLock);
746 validate_object(device, device);
747 validate_object(device, descriptorPool);
748 loader_platform_thread_unlock_mutex(&objLock);
749
750 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->AllocDescriptorSets(
Cody Northropc8aa4a52015-08-03 12:47:29 -0600751 device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600752
753 loader_platform_thread_lock_mutex(&objLock);
Cody Northropc8aa4a52015-08-03 12:47:29 -0600754 for (uint32_t i = 0; i < count; i++) {
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600755 create_obj(device, pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);
756 }
757 loader_platform_thread_unlock_mutex(&objLock);
758
759 return result;
760}
761
762VkResult
Ian Elliott338dedb2015-08-21 15:09:33 -0600763explicit_DestroySwapchainKHR(
Ian Elliottb134e842015-07-06 14:31:32 -0600764 VkDevice device,
Ian Elliott338dedb2015-08-21 15:09:33 -0600765 VkSwapchainKHR swapchain)
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600766{
767
768 loader_platform_thread_lock_mutex(&objLock);
Ian Elliott338dedb2015-08-21 15:09:33 -0600769 destroy_obj(device, swapchain);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600770 loader_platform_thread_unlock_mutex(&objLock);
771
Ian Elliott338dedb2015-08-21 15:09:33 -0600772 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->DestroySwapchainKHR(device, swapchain);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600773
774 return result;
775}
776
777VkResult
778explicit_FreeMemory(
779 VkDevice device,
780 VkDeviceMemory mem)
781{
782 loader_platform_thread_lock_mutex(&objLock);
783 validate_object(device, device);
784 loader_platform_thread_unlock_mutex(&objLock);
785
786 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->FreeMemory(device, mem);
787
788 loader_platform_thread_lock_mutex(&objLock);
789 destroy_obj(device, mem);
790 loader_platform_thread_unlock_mutex(&objLock);
791
792 return result;
793}
Tony Barbour2a199c12015-07-09 17:31:46 -0600794
Tony Barbour912e8152015-07-20 10:52:13 -0600795VkResult
796explicit_FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets)
797{
798 loader_platform_thread_lock_mutex(&objLock);
799 validate_object(device, descriptorPool);
800 validate_object(device, device);
801 loader_platform_thread_unlock_mutex(&objLock);
802 VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
803
804 loader_platform_thread_lock_mutex(&objLock);
Courtney Goeltzenleuchter78fc0472015-07-23 11:25:17 -0600805 for (uint32_t i=0; i<count; i++)
Tony Barbour912e8152015-07-20 10:52:13 -0600806 {
807 destroy_obj(device, *pDescriptorSets++);
808 }
809 loader_platform_thread_unlock_mutex(&objLock);
810 return result;
811}