layers: Split OT inst/dev layer data maps
Including making instance/device versions of object tracking and
validation routines. This is necessary to be consistent with other
layer models.
Change-Id: I13a5942cbef06ca392b32e140bde727d52992946
diff --git a/layers/object_tracker.h b/layers/object_tracker.h
index ed39cbf..c80737b 100644
--- a/layers/object_tracker.h
+++ b/layers/object_tracker.h
@@ -90,28 +90,10 @@
typedef std::unordered_map<uint64_t, ObjTrackState *> object_map_type;
-struct layer_data {
- VkInstance instance;
- VkPhysicalDevice physical_device;
-
+struct object_lifetime {
+ // Include an object_tracker structure
uint64_t num_objects[kVulkanObjectTypeMax + 1];
uint64_t num_total_objects;
- std::unordered_set<std::string> device_extension_set;
-
- debug_report_data *report_data;
- std::vector<VkDebugReportCallbackEXT> logging_callback;
- std::vector<VkDebugUtilsMessengerEXT> logging_messenger;
- // The following are for keeping track of the temporary callbacks that can
- // be used in vkCreateInstance and vkDestroyInstance:
- uint32_t num_tmp_report_callbacks;
- VkDebugReportCallbackCreateInfoEXT *tmp_report_create_infos;
- VkDebugReportCallbackEXT *tmp_report_callbacks;
- uint32_t num_tmp_debug_messengers;
- VkDebugUtilsMessengerCreateInfoEXT *tmp_messenger_create_infos;
- VkDebugUtilsMessengerEXT *tmp_debug_messengers;
-
- std::vector<VkQueueFamilyProperties> queue_family_properties;
-
// Vector of unordered_maps per object type to hold ObjTrackState info
std::vector<object_map_type> object_map;
// Special-case map for swapchain images
@@ -119,29 +101,56 @@
// Map of queue information structures, one per queue
std::unordered_map<VkQueue, ObjTrackQueueInfo *> queue_info_map;
- VkLayerDispatchTable device_dispatch_table;
- VkLayerInstanceDispatchTable instance_dispatch_table;
+ std::vector<VkQueueFamilyProperties> queue_family_properties;
+
// Default constructor
- layer_data()
- : instance(nullptr),
- physical_device(nullptr),
- num_objects{},
- num_total_objects(0),
- report_data(nullptr),
+ object_lifetime() : num_objects{}, num_total_objects(0), object_map{} { object_map.resize(kVulkanObjectTypeMax + 1); }
+};
+
+struct instance_layer_data {
+ object_lifetime objdata;
+ VkInstance instance;
+
+ debug_report_data *report_data;
+ std::vector<VkDebugReportCallbackEXT> logging_callback;
+ std::vector<VkDebugUtilsMessengerEXT> logging_messenger;
+ // The following are for keeping track of the temporary callbacks that can be used in vkCreateInstance and vkDestroyInstance
+ uint32_t num_tmp_report_callbacks;
+ VkDebugReportCallbackCreateInfoEXT *tmp_report_create_infos;
+ VkDebugReportCallbackEXT *tmp_report_callbacks;
+ uint32_t num_tmp_debug_messengers;
+ VkDebugUtilsMessengerCreateInfoEXT *tmp_messenger_create_infos;
+ VkDebugUtilsMessengerEXT *tmp_debug_messengers;
+ VkLayerInstanceDispatchTable instance_dispatch_table;
+
+ // Default constructor
+ instance_layer_data()
+ : report_data(nullptr),
num_tmp_report_callbacks(0),
tmp_report_create_infos(nullptr),
tmp_report_callbacks(nullptr),
num_tmp_debug_messengers(0),
tmp_messenger_create_infos(nullptr),
tmp_debug_messengers(nullptr),
- object_map{},
- device_dispatch_table{},
- instance_dispatch_table{} {
- object_map.resize(kVulkanObjectTypeMax + 1);
- }
+ instance_dispatch_table{} {}
+};
+
+struct layer_data {
+ object_lifetime objdata;
+
+ std::unordered_set<std::string> device_extension_set;
+ debug_report_data *report_data;
+ VkLayerDispatchTable device_dispatch_table;
+
+ instance_layer_data *instance_data;
+ VkPhysicalDevice physical_device;
+
+ // Default constructor
+ layer_data() : instance_data(nullptr), physical_device(nullptr), report_data(nullptr), device_dispatch_table{} {}
};
extern std::unordered_map<void *, layer_data *> layer_data_map;
+extern std::unordered_map<void *, instance_layer_data *> instance_layer_data_map;
extern std::mutex global_lock;
extern uint64_t object_track_index;
extern uint32_t loader_layer_if_version;
@@ -161,8 +170,50 @@
bool ValidateDeviceObject(uint64_t device_handle, const std::string &invalid_handle_code, const std::string &wrong_device_code);
template <typename T1, typename T2>
-bool ValidateObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type, bool null_allowed,
- const std::string &invalid_handle_code, const std::string &wrong_device_code) {
+bool InstanceValidateObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type, bool null_allowed,
+ const std::string &invalid_handle_code, const std::string &wrong_device_code) {
+ if (null_allowed && (object == VK_NULL_HANDLE)) {
+ return false;
+ }
+ auto object_handle = HandleToUint64(object);
+
+ if (object_type == kVulkanObjectTypeDevice) {
+ return ValidateDeviceObject(object_handle, invalid_handle_code, wrong_device_code);
+ }
+
+ VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[object_type];
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), instance_layer_data_map);
+ // Look for object in object map
+ if (instance_data->objdata.object_map[object_type].find(object_handle) ==
+ instance_data->objdata.object_map[object_type].end()) {
+ // Object not found, look for it in other instance object maps
+ for (auto other_instance_data : instance_layer_data_map) {
+ if (other_instance_data.second != instance_data) {
+ if (other_instance_data.second->objdata.object_map[object_type].find(object_handle) !=
+ other_instance_data.second->objdata.object_map[object_type].end()) {
+ // Object found on another instance, report an error if object has a instance parent error code
+ if ((wrong_device_code != kVUIDUndefined) && (object_type != kVulkanObjectTypeSurfaceKHR)) {
+ return log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, object_handle,
+ wrong_device_code,
+ "Object 0x%" PRIxLEAST64
+ " was not created, allocated or retrieved from the correct instance.",
+ object_handle);
+ } else {
+ return false;
+ }
+ }
+ }
+ }
+ // Report an error if object was not found anywhere
+ return log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, object_handle,
+ invalid_handle_code, "Invalid %s Object 0x%" PRIxLEAST64 ".", object_string[object_type], object_handle);
+ }
+ return false;
+}
+
+template <typename T1, typename T2>
+bool DeviceValidateObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type, bool null_allowed,
+ const std::string &invalid_handle_code, const std::string &wrong_device_code) {
if (null_allowed && (object == VK_NULL_HANDLE)) {
return false;
}
@@ -176,24 +227,25 @@
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
// Look for object in device object map
- if (device_data->object_map[object_type].find(object_handle) == device_data->object_map[object_type].end()) {
+ if (device_data->objdata.object_map[object_type].find(object_handle) == device_data->objdata.object_map[object_type].end()) {
// If object is an image, also look for it in the swapchain image map
if ((object_type != kVulkanObjectTypeImage) ||
- (device_data->swapchainImageMap.find(object_handle) == device_data->swapchainImageMap.end())) {
+ (device_data->objdata.swapchainImageMap.find(object_handle) == device_data->objdata.swapchainImageMap.end())) {
// Object not found, look for it in other device object maps
for (auto other_device_data : layer_data_map) {
if (other_device_data.second != device_data) {
- if (other_device_data.second->object_map[object_type].find(object_handle) !=
- other_device_data.second->object_map[object_type].end() ||
- (object_type == kVulkanObjectTypeImage && other_device_data.second->swapchainImageMap.find(object_handle) !=
- other_device_data.second->swapchainImageMap.end())) {
+ if (other_device_data.second->objdata.object_map[object_type].find(object_handle) !=
+ other_device_data.second->objdata.object_map[object_type].end() ||
+ (object_type == kVulkanObjectTypeImage &&
+ other_device_data.second->objdata.swapchainImageMap.find(object_handle) !=
+ other_device_data.second->objdata.swapchainImageMap.end())) {
// Object found on other device, report an error if object has a device parent error code
if ((wrong_device_code != kVUIDUndefined) && (object_type != kVulkanObjectTypeSurfaceKHR)) {
return log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type,
- object_handle, wrong_device_code,
- "Object 0x%" PRIxLEAST64
- " was not created, allocated or retrieved from the correct device.",
- object_handle);
+ object_handle, wrong_device_code,
+ "Object 0x%" PRIxLEAST64
+ " was not created, allocated or retrieved from the correct device.",
+ object_handle);
} else {
return false;
}
@@ -202,94 +254,123 @@
}
// Report an error if object was not found anywhere
return log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, object_handle,
- invalid_handle_code, "Invalid %s Object 0x%" PRIxLEAST64 ".", object_string[object_type], object_handle);
+ invalid_handle_code, "Invalid %s Object 0x%" PRIxLEAST64 ".", object_string[object_type], object_handle);
}
}
return false;
}
-template <typename T1, typename T2>
-void CreateObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type, const VkAllocationCallbacks *pAllocator) {
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
- auto object_handle = HandleToUint64(object);
- bool custom_allocator = pAllocator != nullptr;
- if (!instance_data->object_map[object_type].count(object_handle)) {
+
+
+static void InsertObjectInMap(uint64_t object_handle, VulkanObjectType object_type, object_lifetime *obj_data,
+ debug_report_data *report_data, bool custom_allocator) {
+ if (!obj_data->object_map[object_type].count(object_handle)) {
VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[object_type];
- log_msg(instance_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, debug_object_type, object_handle,
- kVUID_ObjectTracker_Info, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++,
- object_string[object_type], object_handle);
+ log_msg(report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, debug_object_type, object_handle, kVUID_ObjectTracker_Info,
+ "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++, object_string[object_type],
+ object_handle);
ObjTrackState *pNewObjNode = new ObjTrackState;
pNewObjNode->object_type = object_type;
pNewObjNode->status = custom_allocator ? OBJSTATUS_CUSTOM_ALLOCATOR : OBJSTATUS_NONE;
pNewObjNode->handle = object_handle;
- instance_data->object_map[object_type][object_handle] = pNewObjNode;
- instance_data->num_objects[object_type]++;
- instance_data->num_total_objects++;
+ obj_data->object_map[object_type][object_handle] = pNewObjNode;
+ obj_data->num_objects[object_type]++;
+ obj_data->num_total_objects++;
}
}
template <typename T1, typename T2>
-void DestroyObjectSilently(T1 dispatchable_object, T2 object, VulkanObjectType object_type) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
-
- auto object_handle = HandleToUint64(object);
- assert(object_handle != VK_NULL_HANDLE);
-
- auto item = device_data->object_map[object_type].find(object_handle);
- assert(item != device_data->object_map[object_type].end());
-
- ObjTrackState *pNode = item->second;
- assert(device_data->num_total_objects > 0);
-
- device_data->num_total_objects--;
- assert(device_data->num_objects[pNode->object_type] > 0);
-
- device_data->num_objects[pNode->object_type]--;
-
- delete pNode;
- device_data->object_map[object_type].erase(item);
+void InstanceCreateObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type,
+ const VkAllocationCallbacks *pAllocator) {
+ instance_layer_data *layer_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), instance_layer_data_map);
+ InsertObjectInMap(HandleToUint64(object), object_type, &layer_data->objdata, layer_data->report_data, (pAllocator != nullptr));
}
template <typename T1, typename T2>
-bool ValidateDestroyObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type, const VkAllocationCallbacks *pAllocator,
- const std::string &expected_custom_allocator_code, const std::string &expected_default_allocator_code) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
- bool skip = false;
+void DeviceCreateObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type, const VkAllocationCallbacks *pAllocator) {
+ layer_data *layer_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
+ InsertObjectInMap(HandleToUint64(object), object_type, &layer_data->objdata, layer_data->report_data, (pAllocator != nullptr));
+}
+template <typename T1>
+void DestroyObjectSilently(object_lifetime *obj_data, T1 object, VulkanObjectType object_type) {
+ auto object_handle = HandleToUint64(object);
+ assert(object_handle != VK_NULL_HANDLE);
+
+ auto item = obj_data->object_map[object_type].find(object_handle);
+ assert(item != obj_data->object_map[object_type].end());
+
+ ObjTrackState *pNode = item->second;
+ assert(obj_data->num_total_objects > 0);
+
+ obj_data->num_total_objects--;
+ assert(obj_data->num_objects[pNode->object_type] > 0);
+
+ obj_data->num_objects[pNode->object_type]--;
+
+ delete pNode;
+ obj_data->object_map[object_type].erase(item);
+}
+
+template <typename T1>
+void DeleteObjectFromMap(T1 object, VulkanObjectType object_type, object_lifetime *obj_data) {
+ auto object_handle = HandleToUint64(object);
+ if (object_handle != VK_NULL_HANDLE) {
+ auto item = obj_data->object_map[object_type].find(object_handle);
+ if (item != obj_data->object_map[object_type].end()) {
+ DestroyObjectSilently(obj_data, object, object_type);
+ }
+ }
+}
+
+template <typename T1, typename T2>
+void InstanceRecordDestroyObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type) {
+ instance_layer_data *layer_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), instance_layer_data_map);
+ DeleteObjectFromMap(object, object_type, &layer_data->objdata);
+}
+
+template <typename T1, typename T2>
+void DeviceRecordDestroyObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type) {
+ layer_data *layer_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
+ DeleteObjectFromMap(object, object_type, &layer_data->objdata);
+}
+
+template <typename T1>
+bool ValidateDestroyObject(T1 object, VulkanObjectType object_type, const VkAllocationCallbacks *pAllocator,
+ const std::string &expected_custom_allocator_code, const std::string &expected_default_allocator_code,
+ object_lifetime *obj_data, debug_report_data *report_data) {
auto object_handle = HandleToUint64(object);
bool custom_allocator = pAllocator != nullptr;
VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[object_type];
+ bool skip = false;
if (object_handle != VK_NULL_HANDLE) {
- auto item = device_data->object_map[object_type].find(object_handle);
- if (item != device_data->object_map[object_type].end()) {
+ auto item = obj_data->object_map[object_type].find(object_handle);
+ if (item != obj_data->object_map[object_type].end()) {
ObjTrackState *pNode = item->second;
-
- skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, debug_object_type, object_handle,
+ skip |= log_msg(report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, debug_object_type, object_handle,
kVUID_ObjectTracker_Info,
"OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).",
- object_string[object_type], HandleToUint64(object), device_data->num_total_objects - 1,
- device_data->num_objects[pNode->object_type] - 1, object_string[object_type]);
+ object_string[object_type], HandleToUint64(object), obj_data->num_total_objects - 1,
+ obj_data->num_objects[pNode->object_type] - 1, object_string[object_type]);
auto allocated_with_custom = (pNode->status & OBJSTATUS_CUSTOM_ALLOCATOR) ? true : false;
if (allocated_with_custom && !custom_allocator && expected_custom_allocator_code != kVUIDUndefined) {
// This check only verifies that custom allocation callbacks were provided to both Create and Destroy calls,
// it cannot verify that these allocation callbacks are compatible with each other.
- skip |=
- log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, object_handle,
- expected_custom_allocator_code,
- "Custom allocator not specified while destroying %s obj 0x%" PRIxLEAST64 " but specified at creation.",
- object_string[object_type], object_handle);
+ skip |= log_msg(
+ report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, object_handle, expected_custom_allocator_code,
+ "Custom allocator not specified while destroying %s obj 0x%" PRIxLEAST64 " but specified at creation.",
+ object_string[object_type], object_handle);
} else if (!allocated_with_custom && custom_allocator && expected_default_allocator_code != kVUIDUndefined) {
- skip |=
- log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, object_handle,
- expected_default_allocator_code,
- "Custom allocator specified while destroying %s obj 0x%" PRIxLEAST64 " but not specified at creation.",
- object_string[object_type], object_handle);
+ skip |= log_msg(
+ report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, object_handle, expected_default_allocator_code,
+ "Custom allocator specified while destroying %s obj 0x%" PRIxLEAST64 " but not specified at creation.",
+ object_string[object_type], object_handle);
}
}
}
@@ -297,17 +378,21 @@
}
template <typename T1, typename T2>
-void RecordDestroyObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
+bool InstanceValidateDestroyObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type,
+ const VkAllocationCallbacks *pAllocator, const std::string &expected_custom_allocator_code,
+ const std::string &expected_default_allocator_code) {
+ instance_layer_data *layer_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), instance_layer_data_map);
+ return ValidateDestroyObject(object, object_type, pAllocator, expected_custom_allocator_code, expected_default_allocator_code,
+ &layer_data->objdata, layer_data->report_data);
+}
- auto object_handle = HandleToUint64(object);
-
- if (object_handle != VK_NULL_HANDLE) {
- auto item = device_data->object_map[object_type].find(object_handle);
- if (item != device_data->object_map[object_type].end()) {
- DestroyObjectSilently(dispatchable_object, object, object_type);
- }
- }
+template <typename T1, typename T2>
+bool DeviceValidateDestroyObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type,
+ const VkAllocationCallbacks *pAllocator, const std::string &expected_custom_allocator_code,
+ const std::string &expected_default_allocator_code) {
+ layer_data *layer_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
+ return ValidateDestroyObject(object, object_type, pAllocator, expected_custom_allocator_code, expected_default_allocator_code,
+ &layer_data->objdata, layer_data->report_data);
}
} // namespace object_tracker
diff --git a/layers/object_tracker_utils.cpp b/layers/object_tracker_utils.cpp
index 54d2cb6..9685d94 100644
--- a/layers/object_tracker_utils.cpp
+++ b/layers/object_tracker_utils.cpp
@@ -25,25 +25,26 @@
namespace object_tracker {
std::unordered_map<void *, layer_data *> layer_data_map;
+std::unordered_map<void *, instance_layer_data *> instance_layer_data_map;
std::mutex global_lock;
uint64_t object_track_index = 0;
uint32_t loader_layer_if_version = CURRENT_LOADER_LAYER_INTERFACE_VERSION;
-void InitObjectTracker(layer_data *my_data, const VkAllocationCallbacks *pAllocator) {
+void InitObjectTracker(instance_layer_data *my_data, const VkAllocationCallbacks *pAllocator) {
layer_debug_messenger_actions(my_data->report_data, my_data->logging_messenger, pAllocator, "lunarg_object_tracker");
}
// Add new queue to head of global queue list
void AddQueueInfo(VkDevice device, uint32_t queue_node_index, VkQueue queue) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- auto queueItem = device_data->queue_info_map.find(queue);
- if (queueItem == device_data->queue_info_map.end()) {
+ auto queueItem = device_data->objdata.queue_info_map.find(queue);
+ if (queueItem == device_data->objdata.queue_info_map.end()) {
ObjTrackQueueInfo *p_queue_info = new ObjTrackQueueInfo;
if (p_queue_info != NULL) {
memset(p_queue_info, 0, sizeof(ObjTrackQueueInfo));
p_queue_info->queue = queue;
p_queue_info->queue_node_index = queue_node_index;
- device_data->queue_info_map[queue] = p_queue_info;
+ device_data->objdata.queue_info_map[queue] = p_queue_info;
} else {
log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
HandleToUint64(queue), kVUID_ObjectTracker_InternalError,
@@ -56,38 +57,39 @@
void DestroyQueueDataStructures(VkDevice device) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- for (auto queue_item : device_data->queue_info_map) {
+ for (auto queue_item : device_data->objdata.queue_info_map) {
delete queue_item.second;
}
- device_data->queue_info_map.clear();
+ device_data->objdata.queue_info_map.clear();
// Destroy the items in the queue map
- auto queue = device_data->object_map[kVulkanObjectTypeQueue].begin();
- while (queue != device_data->object_map[kVulkanObjectTypeQueue].end()) {
+ auto queue = device_data->objdata.object_map[kVulkanObjectTypeQueue].begin();
+ while (queue != device_data->objdata.object_map[kVulkanObjectTypeQueue].end()) {
uint32_t obj_index = queue->second->object_type;
- assert(device_data->num_total_objects > 0);
- device_data->num_total_objects--;
- assert(device_data->num_objects[obj_index] > 0);
- device_data->num_objects[obj_index]--;
+ assert(device_data->objdata.num_total_objects > 0);
+ device_data->objdata.num_total_objects--;
+ assert(device_data->objdata.num_objects[obj_index] > 0);
+ device_data->objdata.num_objects[obj_index]--;
log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
queue->second->handle, kVUID_ObjectTracker_Info,
"OBJ_STAT Destroy Queue obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " Queue objs).",
- queue->second->handle, device_data->num_total_objects, device_data->num_objects[obj_index]);
+ queue->second->handle, device_data->objdata.num_total_objects, device_data->objdata.num_objects[obj_index]);
delete queue->second;
- queue = device_data->object_map[kVulkanObjectTypeQueue].erase(queue);
+ queue = device_data->objdata.object_map[kVulkanObjectTypeQueue].erase(queue);
}
}
// Check Queue type flags for selected queue operations
void ValidateQueueFlags(VkQueue queue, const char *function) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
- auto queue_item = device_data->queue_info_map.find(queue);
- if (queue_item != device_data->queue_info_map.end()) {
+ auto queue_item = device_data->objdata.queue_info_map.find(queue);
+ if (queue_item != device_data->objdata.queue_info_map.end()) {
ObjTrackQueueInfo *pQueueInfo = queue_item->second;
if (pQueueInfo != NULL) {
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(device_data->physical_device), layer_data_map);
- if ((instance_data->queue_family_properties[pQueueInfo->queue_node_index].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) ==
- 0) {
+ instance_layer_data *instance_data =
+ GetLayerDataPtr(get_dispatch_key(device_data->physical_device), instance_layer_data_map);
+ if ((instance_data->objdata.queue_family_properties[pQueueInfo->queue_node_index].queueFlags &
+ VK_QUEUE_SPARSE_BINDING_BIT) == 0) {
log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
HandleToUint64(queue), "VUID-vkQueueBindSparse-queuetype",
"Attempting %s on a non-memory-management capable queue -- VK_QUEUE_SPARSE_BINDING_BIT not set.", function);
@@ -101,15 +103,15 @@
// However, if this layer is loaded first and GetProcAddress is used to make API calls, it will detect bad DOs.
bool ValidateDeviceObject(uint64_t device_handle, const std::string &invalid_handle_code, const std::string &wrong_device_code) {
VkInstance last_instance = nullptr;
- for (auto layer_data : layer_data_map) {
- for (auto object : layer_data.second->object_map[kVulkanObjectTypeDevice]) {
+ for (auto instance_data : instance_layer_data_map) {
+ for (auto object : instance_data.second->objdata.object_map[kVulkanObjectTypeDevice]) {
// Grab last instance to use for possible error message
- last_instance = layer_data.second->instance;
+ last_instance = instance_data.second->instance;
if (object.second->handle == device_handle) return false;
}
}
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(last_instance), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(last_instance), instance_layer_data_map);
return log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, device_handle,
invalid_handle_code, "Invalid Device Object 0x%" PRIxLEAST64 ".", device_handle);
}
@@ -131,18 +133,18 @@
} else {
pNewObjNode->status = OBJSTATUS_NONE;
}
- device_data->object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)] = pNewObjNode;
- device_data->num_objects[kVulkanObjectTypeCommandBuffer]++;
- device_data->num_total_objects++;
+ device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)] = pNewObjNode;
+ device_data->objdata.num_objects[kVulkanObjectTypeCommandBuffer]++;
+ device_data->objdata.num_total_objects++;
}
bool ValidateCommandBuffer(VkDevice device, VkCommandPool command_pool, VkCommandBuffer command_buffer) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
uint64_t object_handle = HandleToUint64(command_buffer);
- if (device_data->object_map[kVulkanObjectTypeCommandBuffer].find(object_handle) !=
- device_data->object_map[kVulkanObjectTypeCommandBuffer].end()) {
- ObjTrackState *pNode = device_data->object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)];
+ if (device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer].find(object_handle) !=
+ device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer].end()) {
+ ObjTrackState *pNode = device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)];
if (pNode->parent_object != HandleToUint64(command_pool)) {
skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
@@ -171,17 +173,17 @@
pNewObjNode->status = OBJSTATUS_NONE;
pNewObjNode->handle = HandleToUint64(descriptor_set);
pNewObjNode->parent_object = HandleToUint64(descriptor_pool);
- device_data->object_map[kVulkanObjectTypeDescriptorSet][HandleToUint64(descriptor_set)] = pNewObjNode;
- device_data->num_objects[kVulkanObjectTypeDescriptorSet]++;
- device_data->num_total_objects++;
+ device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet][HandleToUint64(descriptor_set)] = pNewObjNode;
+ device_data->objdata.num_objects[kVulkanObjectTypeDescriptorSet]++;
+ device_data->objdata.num_total_objects++;
}
bool ValidateDescriptorSet(VkDevice device, VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
uint64_t object_handle = HandleToUint64(descriptor_set);
- auto dsItem = device_data->object_map[kVulkanObjectTypeDescriptorSet].find(object_handle);
- if (dsItem != device_data->object_map[kVulkanObjectTypeDescriptorSet].end()) {
+ auto dsItem = device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet].find(object_handle);
+ if (dsItem != device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet].end()) {
ObjTrackState *pNode = dsItem->second;
if (pNode->parent_object != HandleToUint64(descriptor_pool)) {
@@ -204,15 +206,16 @@
bool skip = false;
if (!isPush && desc->dstSet) {
- skip |= ValidateObject(disp, desc->dstSet, kVulkanObjectTypeDescriptorSet, false, "VUID-VkWriteDescriptorSet-dstSet-00320",
- "VUID-VkWriteDescriptorSet-commonparent");
+ skip |= DeviceValidateObject(disp, desc->dstSet, kVulkanObjectTypeDescriptorSet, false,
+ "VUID-VkWriteDescriptorSet-dstSet-00320", "VUID-VkWriteDescriptorSet-commonparent");
}
if ((desc->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) ||
(desc->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)) {
for (uint32_t idx2 = 0; idx2 < desc->descriptorCount; ++idx2) {
- skip |= ValidateObject(disp, desc->pTexelBufferView[idx2], kVulkanObjectTypeBufferView, false,
- "VUID-VkWriteDescriptorSet-descriptorType-00323", "VUID-VkWriteDescriptorSet-commonparent");
+ skip |=
+ DeviceValidateObject(disp, desc->pTexelBufferView[idx2], kVulkanObjectTypeBufferView, false,
+ "VUID-VkWriteDescriptorSet-descriptorType-00323", "VUID-VkWriteDescriptorSet-commonparent");
}
}
@@ -220,8 +223,9 @@
(desc->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) || (desc->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) ||
(desc->descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)) {
for (uint32_t idx3 = 0; idx3 < desc->descriptorCount; ++idx3) {
- skip |= ValidateObject(disp, desc->pImageInfo[idx3].imageView, kVulkanObjectTypeImageView, false,
- "VUID-VkWriteDescriptorSet-descriptorType-00326", "VUID-VkDescriptorImageInfo-commonparent");
+ skip |=
+ DeviceValidateObject(disp, desc->pImageInfo[idx3].imageView, kVulkanObjectTypeImageView, false,
+ "VUID-VkWriteDescriptorSet-descriptorType-00326", "VUID-VkDescriptorImageInfo-commonparent");
}
}
@@ -231,8 +235,8 @@
(desc->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) {
for (uint32_t idx4 = 0; idx4 < desc->descriptorCount; ++idx4) {
if (desc->pBufferInfo[idx4].buffer) {
- skip |= ValidateObject(disp, desc->pBufferInfo[idx4].buffer, kVulkanObjectTypeBuffer, false,
- "VUID-VkDescriptorBufferInfo-buffer-parameter", kVUIDUndefined);
+ skip |= DeviceValidateObject(disp, desc->pBufferInfo[idx4].buffer, kVulkanObjectTypeBuffer, false,
+ "VUID-VkDescriptorBufferInfo-buffer-parameter", kVUIDUndefined);
}
}
}
@@ -244,10 +248,11 @@
VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount,
const VkWriteDescriptorSet *pDescriptorWrites) {
bool skip = false;
- skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false,
- "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-parameter", "VUID-vkCmdPushDescriptorSetKHR-commonparent");
- skip |= ValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false,
- "VUID-vkCmdPushDescriptorSetKHR-layout-parameter", "VUID-vkCmdPushDescriptorSetKHR-commonparent");
+ skip |= DeviceValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false,
+ "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-parameter",
+ "VUID-vkCmdPushDescriptorSetKHR-commonparent");
+ skip |= DeviceValidateObject(commandBuffer, layout, kVulkanObjectTypePipelineLayout, false,
+ "VUID-vkCmdPushDescriptorSetKHR-layout-parameter", "VUID-vkCmdPushDescriptorSetKHR-commonparent");
if (pDescriptorWrites) {
for (uint32_t index0 = 0; index0 < descriptorWriteCount; ++index0) {
skip |= ValidateDescriptorWrite(commandBuffer, &pDescriptorWrites[index0], true);
@@ -279,12 +284,12 @@
object_track_index++, "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT", HandleToUint64(vkObj));
ObjTrackState *p_obj_node = NULL;
- auto queue_item = device_data->object_map[kVulkanObjectTypeQueue].find(HandleToUint64(vkObj));
- if (queue_item == device_data->object_map[kVulkanObjectTypeQueue].end()) {
+ auto queue_item = device_data->objdata.object_map[kVulkanObjectTypeQueue].find(HandleToUint64(vkObj));
+ if (queue_item == device_data->objdata.object_map[kVulkanObjectTypeQueue].end()) {
p_obj_node = new ObjTrackState;
- device_data->object_map[kVulkanObjectTypeQueue][HandleToUint64(vkObj)] = p_obj_node;
- device_data->num_objects[kVulkanObjectTypeQueue]++;
- device_data->num_total_objects++;
+ device_data->objdata.object_map[kVulkanObjectTypeQueue][HandleToUint64(vkObj)] = p_obj_node;
+ device_data->objdata.num_objects[kVulkanObjectTypeQueue]++;
+ device_data->objdata.num_total_objects++;
} else {
p_obj_node = queue_item->second;
}
@@ -304,13 +309,13 @@
pNewObjNode->status = OBJSTATUS_NONE;
pNewObjNode->handle = HandleToUint64(swapchain_image);
pNewObjNode->parent_object = HandleToUint64(swapchain);
- device_data->swapchainImageMap[HandleToUint64(swapchain_image)] = pNewObjNode;
+ device_data->objdata.swapchainImageMap[HandleToUint64(swapchain_image)] = pNewObjNode;
}
bool DeviceReportUndestroyedObjects(VkDevice device, VulkanObjectType object_type, const std::string &error_code) {
bool skip = false;
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- for (const auto &item : device_data->object_map[object_type]) {
+ for (const auto &item : device_data->objdata.object_map[object_type]) {
const ObjTrackState *object_info = item.second;
skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, get_debug_report_enum[object_type],
object_info->handle, error_code,
@@ -322,25 +327,25 @@
void DeviceDestroyUndestroyedObjects(VkDevice device, VulkanObjectType object_type) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- while (!device_data->object_map[object_type].empty()) {
- auto item = device_data->object_map[object_type].begin();
+ while (!device_data->objdata.object_map[object_type].empty()) {
+ auto item = device_data->objdata.object_map[object_type].begin();
ObjTrackState *object_info = item->second;
- DestroyObjectSilently(device, object_info->handle, object_type);
+ DestroyObjectSilently(&device_data->objdata, object_info->handle, object_type);
}
}
static bool PreCallValidateDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(instance);
- layer_data *instance_data = GetLayerDataPtr(key, layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map);
bool skip = false;
// We validate here for coverage, though we'd not have made it this for with a bad instance.
- skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, true, "VUID-vkDestroyInstance-instance-parameter",
- kVUIDUndefined);
+ skip |= InstanceValidateObject(instance, instance, kVulkanObjectTypeInstance, true, "VUID-vkDestroyInstance-instance-parameter",
+ kVUIDUndefined);
// Validate that child devices have been destroyed
- for (const auto &iit : instance_data->object_map[kVulkanObjectTypeDevice]) {
+ for (const auto &iit : instance_data->objdata.object_map[kVulkanObjectTypeDevice]) {
ObjTrackState *pNode = iit.second;
VkDevice device = reinterpret_cast<VkDevice>(pNode->handle);
@@ -353,19 +358,19 @@
// Report any remaining objects in LL
skip |= ReportUndestroyedObjects(device, "VUID-vkDestroyInstance-instance-00629");
- skip |= ValidateDestroyObject(instance, device, kVulkanObjectTypeDevice, pAllocator,
- "VUID-vkDestroyInstance-instance-00630", "VUID-vkDestroyInstance-instance-00631");
+ skip |= InstanceValidateDestroyObject(instance, device, kVulkanObjectTypeDevice, pAllocator,
+ "VUID-vkDestroyInstance-instance-00630", "VUID-vkDestroyInstance-instance-00631");
}
- ValidateDestroyObject(instance, instance, kVulkanObjectTypeInstance, pAllocator, "VUID-vkDestroyInstance-instance-00630",
- "VUID-vkDestroyInstance-instance-00631");
+ InstanceValidateDestroyObject(instance, instance, kVulkanObjectTypeInstance, pAllocator,
+ "VUID-vkDestroyInstance-instance-00630", "VUID-vkDestroyInstance-instance-00631");
return skip;
}
static void PreCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(instance);
- layer_data *instance_data = GetLayerDataPtr(key, layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map);
// Enable the temporary callback(s) here to catch cleanup issues:
if (instance_data->num_tmp_debug_messengers > 0) {
@@ -378,31 +383,31 @@
}
// Destroy physical devices
- for (auto iit = instance_data->object_map[kVulkanObjectTypePhysicalDevice].begin();
- iit != instance_data->object_map[kVulkanObjectTypePhysicalDevice].end();) {
+ for (auto iit = instance_data->objdata.object_map[kVulkanObjectTypePhysicalDevice].begin();
+ iit != instance_data->objdata.object_map[kVulkanObjectTypePhysicalDevice].end();) {
ObjTrackState *pNode = iit->second;
VkPhysicalDevice physical_device = reinterpret_cast<VkPhysicalDevice>(pNode->handle);
- RecordDestroyObject(instance, physical_device, kVulkanObjectTypePhysicalDevice);
- iit = instance_data->object_map[kVulkanObjectTypePhysicalDevice].begin();
+ InstanceRecordDestroyObject(instance, physical_device, kVulkanObjectTypePhysicalDevice);
+ iit = instance_data->objdata.object_map[kVulkanObjectTypePhysicalDevice].begin();
}
// Destroy child devices
- for (auto iit = instance_data->object_map[kVulkanObjectTypeDevice].begin();
- iit != instance_data->object_map[kVulkanObjectTypeDevice].end();) {
+ for (auto iit = instance_data->objdata.object_map[kVulkanObjectTypeDevice].begin();
+ iit != instance_data->objdata.object_map[kVulkanObjectTypeDevice].end();) {
ObjTrackState *pNode = iit->second;
VkDevice device = reinterpret_cast<VkDevice>(pNode->handle);
DestroyUndestroyedObjects(device);
- RecordDestroyObject(instance, device, kVulkanObjectTypeDevice);
- iit = instance_data->object_map[kVulkanObjectTypeDevice].begin();
+ InstanceRecordDestroyObject(instance, device, kVulkanObjectTypeDevice);
+ iit = instance_data->objdata.object_map[kVulkanObjectTypeDevice].begin();
}
- instance_data->object_map[kVulkanObjectTypeDevice].clear();
+ instance_data->objdata.object_map[kVulkanObjectTypeDevice].clear();
}
static void PostCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(instance);
- layer_data *instance_data = GetLayerDataPtr(key, layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map);
// Disable and cleanup the temporary callback(s):
layer_disable_tmp_debug_messengers(instance_data->report_data, instance_data->num_tmp_debug_messengers,
@@ -430,15 +435,15 @@
instance_data->logging_callback.pop_back();
}
- RecordDestroyObject(instance, instance, kVulkanObjectTypeInstance);
+ InstanceRecordDestroyObject(instance, instance, kVulkanObjectTypeInstance);
layer_debug_utils_destroy_instance(instance_data->report_data);
- FreeLayerDataPtr(key, layer_data_map);
+ FreeLayerDataPtr(key, instance_layer_data_map);
}
VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(instance);
- layer_data *instance_data = GetLayerDataPtr(key, layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map);
{
std::lock_guard<std::mutex> lock(global_lock);
bool skip = PreCallValidateDestroyInstance(instance, pAllocator);
@@ -455,9 +460,10 @@
static bool PreCallValidateDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, true, "VUID-vkDestroyDevice-device-parameter", kVUIDUndefined);
- skip |= ValidateDestroyObject(device_data->instance, device, kVulkanObjectTypeDevice, pAllocator,
- "VUID-vkDestroyDevice-device-00379", "VUID-vkDestroyDevice-device-00380");
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, true, "VUID-vkDestroyDevice-device-parameter",
+ kVUIDUndefined);
+ skip |= InstanceValidateDestroyObject(device_data->physical_device, device, kVulkanObjectTypeDevice, pAllocator,
+ "VUID-vkDestroyDevice-device-00379", "VUID-vkDestroyDevice-device-00380");
// Report any remaining objects associated with this VkDevice object in LL
skip |= ReportUndestroyedObjects(device, "VUID-vkDestroyDevice-device-00378");
@@ -466,7 +472,7 @@
static void PreCallRecordDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- RecordDestroyObject(device_data->instance, device, kVulkanObjectTypeDevice);
+ InstanceRecordDestroyObject(device_data->physical_device, device, kVulkanObjectTypeDevice);
DestroyUndestroyedObjects(device);
// Clean up Queue's MemRef Linked Lists
@@ -489,8 +495,8 @@
static bool PreCallValidateGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) {
bool skip = false;
- skip |=
- ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceQueue-device-parameter", kVUIDUndefined);
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceQueue-device-parameter",
+ kVUIDUndefined);
return skip;
}
@@ -516,10 +522,8 @@
}
static bool PreCallValidateGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) {
- bool skip = false;
- skip |=
- ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceQueue2-device-parameter", kVUIDUndefined);
- return skip;
+ return DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceQueue2-device-parameter",
+ kVUIDUndefined);
}
static void PostCallRecordGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) {
@@ -547,17 +551,17 @@
const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount,
const VkCopyDescriptorSet *pDescriptorCopies) {
bool skip = false;
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkUpdateDescriptorSets-device-parameter",
- kVUIDUndefined);
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkUpdateDescriptorSets-device-parameter",
+ kVUIDUndefined);
if (pDescriptorCopies) {
for (uint32_t idx0 = 0; idx0 < descriptorCopyCount; ++idx0) {
if (pDescriptorCopies[idx0].dstSet) {
- skip |= ValidateObject(device, pDescriptorCopies[idx0].dstSet, kVulkanObjectTypeDescriptorSet, false,
- "VUID-VkCopyDescriptorSet-dstSet-parameter", "VUID-VkCopyDescriptorSet-commonparent");
+ skip |= DeviceValidateObject(device, pDescriptorCopies[idx0].dstSet, kVulkanObjectTypeDescriptorSet, false,
+ "VUID-VkCopyDescriptorSet-dstSet-parameter", "VUID-VkCopyDescriptorSet-commonparent");
}
if (pDescriptorCopies[idx0].srcSet) {
- skip |= ValidateObject(device, pDescriptorCopies[idx0].srcSet, kVulkanObjectTypeDescriptorSet, false,
- "VUID-VkCopyDescriptorSet-srcSet-parameter", "VUID-VkCopyDescriptorSet-commonparent");
+ skip |= DeviceValidateObject(device, pDescriptorCopies[idx0].srcSet, kVulkanObjectTypeDescriptorSet, false,
+ "VUID-VkCopyDescriptorSet-srcSet-parameter", "VUID-VkCopyDescriptorSet-commonparent");
}
}
}
@@ -587,30 +591,30 @@
const VkComputePipelineCreateInfo *pCreateInfos,
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
bool skip = VK_FALSE;
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateComputePipelines-device-parameter",
- kVUIDUndefined);
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateComputePipelines-device-parameter",
+ kVUIDUndefined);
if (pCreateInfos) {
for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
if (pCreateInfos[idx0].basePipelineHandle) {
- skip |=
- ValidateObject(device, pCreateInfos[idx0].basePipelineHandle, kVulkanObjectTypePipeline, true,
- "VUID-VkComputePipelineCreateInfo-flags-00697", "VUID-VkComputePipelineCreateInfo-commonparent");
+ skip |= DeviceValidateObject(device, pCreateInfos[idx0].basePipelineHandle, kVulkanObjectTypePipeline, true,
+ "VUID-VkComputePipelineCreateInfo-flags-00697",
+ "VUID-VkComputePipelineCreateInfo-commonparent");
}
if (pCreateInfos[idx0].layout) {
- skip |= ValidateObject(device, pCreateInfos[idx0].layout, kVulkanObjectTypePipelineLayout, false,
- "VUID-VkComputePipelineCreateInfo-layout-parameter",
- "VUID-VkComputePipelineCreateInfo-commonparent");
+ skip |= DeviceValidateObject(device, pCreateInfos[idx0].layout, kVulkanObjectTypePipelineLayout, false,
+ "VUID-VkComputePipelineCreateInfo-layout-parameter",
+ "VUID-VkComputePipelineCreateInfo-commonparent");
}
if (pCreateInfos[idx0].stage.module) {
- skip |= ValidateObject(device, pCreateInfos[idx0].stage.module, kVulkanObjectTypeShaderModule, false,
- "VUID-VkPipelineShaderStageCreateInfo-module-parameter", kVUIDUndefined);
+ skip |= DeviceValidateObject(device, pCreateInfos[idx0].stage.module, kVulkanObjectTypeShaderModule, false,
+ "VUID-VkPipelineShaderStageCreateInfo-module-parameter", kVUIDUndefined);
}
}
}
if (pipelineCache) {
- skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true,
- "VUID-vkCreateComputePipelines-pipelineCache-parameter",
- "VUID-vkCreateComputePipelines-pipelineCache-parent");
+ skip |= DeviceValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true,
+ "VUID-vkCreateComputePipelines-pipelineCache-parameter",
+ "VUID-vkCreateComputePipelines-pipelineCache-parent");
}
if (skip) {
for (uint32_t i = 0; i < createInfoCount; i++) {
@@ -625,7 +629,7 @@
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
for (uint32_t idx1 = 0; idx1 < createInfoCount; ++idx1) {
if (pPipelines[idx1] != VK_NULL_HANDLE) {
- CreateObject(device, pPipelines[idx1], kVulkanObjectTypePipeline, pAllocator);
+ DeviceCreateObject(device, pPipelines[idx1], kVulkanObjectTypePipeline, pAllocator);
}
}
}
@@ -653,15 +657,15 @@
bool skip = false;
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkResetDescriptorPool-device-parameter",
- kVUIDUndefined);
- skip |=
- ValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, false,
- "VUID-vkResetDescriptorPool-descriptorPool-parameter", "VUID-vkResetDescriptorPool-descriptorPool-parent");
- for (const auto &itr : device_data->object_map[kVulkanObjectTypeDescriptorSet]) {
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkResetDescriptorPool-device-parameter",
+ kVUIDUndefined);
+ skip |= DeviceValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, false,
+ "VUID-vkResetDescriptorPool-descriptorPool-parameter",
+ "VUID-vkResetDescriptorPool-descriptorPool-parent");
+ for (const auto &itr : device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet]) {
if (itr.second->parent_object == HandleToUint64(descriptorPool)) {
- skip |= ValidateDestroyObject(device, (VkDescriptorSet)(itr.first), kVulkanObjectTypeDescriptorSet, nullptr,
- kVUIDUndefined, kVUIDUndefined);
+ skip |= DeviceValidateDestroyObject(device, (VkDescriptorSet)(itr.first), kVulkanObjectTypeDescriptorSet, nullptr,
+ kVUIDUndefined, kVUIDUndefined);
}
}
return skip;
@@ -672,12 +676,12 @@
// A DescriptorPool's descriptor sets are implicitly deleted when the pool is reset. Remove this pool's descriptor sets from
// our descriptorSet map.
- auto itr = device_data->object_map[kVulkanObjectTypeDescriptorSet].begin();
- while (itr != device_data->object_map[kVulkanObjectTypeDescriptorSet].end()) {
+ auto itr = device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet].begin();
+ while (itr != device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet].end()) {
ObjTrackState *pNode = (*itr).second;
auto del_itr = itr++;
if (pNode->parent_object == HandleToUint64(descriptorPool)) {
- RecordDestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet);
+ DeviceRecordDestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet);
}
}
}
@@ -698,16 +702,18 @@
static bool PreCallValidateBeginCommandBuffer(VkCommandBuffer command_buffer, const VkCommandBufferBeginInfo *begin_info) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(command_buffer), layer_data_map);
bool skip = false;
- skip |= ValidateObject(command_buffer, command_buffer, kVulkanObjectTypeCommandBuffer, false,
- "VUID-vkBeginCommandBuffer-commandBuffer-parameter", kVUIDUndefined);
+ skip |= DeviceValidateObject(command_buffer, command_buffer, kVulkanObjectTypeCommandBuffer, false,
+ "VUID-vkBeginCommandBuffer-commandBuffer-parameter", kVUIDUndefined);
if (begin_info) {
- ObjTrackState *pNode = device_data->object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)];
+ ObjTrackState *pNode = device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)];
if ((begin_info->pInheritanceInfo) && (pNode->status & OBJSTATUS_COMMAND_BUFFER_SECONDARY) &&
(begin_info->flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) {
- skip |= ValidateObject(command_buffer, begin_info->pInheritanceInfo->framebuffer, kVulkanObjectTypeFramebuffer, true,
- "VUID-VkCommandBufferBeginInfo-flags-00055", "VUID-VkCommandBufferInheritanceInfo-commonparent");
- skip |= ValidateObject(command_buffer, begin_info->pInheritanceInfo->renderPass, kVulkanObjectTypeRenderPass, false,
- "VUID-VkCommandBufferBeginInfo-flags-00053", "VUID-VkCommandBufferInheritanceInfo-commonparent");
+ skip |= DeviceValidateObject(command_buffer, begin_info->pInheritanceInfo->framebuffer, kVulkanObjectTypeFramebuffer,
+ true, "VUID-VkCommandBufferBeginInfo-flags-00055",
+ "VUID-VkCommandBufferInheritanceInfo-commonparent");
+ skip |= DeviceValidateObject(command_buffer, begin_info->pInheritanceInfo->renderPass, kVulkanObjectTypeRenderPass,
+ false, "VUID-VkCommandBufferBeginInfo-flags-00053",
+ "VUID-VkCommandBufferInheritanceInfo-commonparent");
}
}
return skip;
@@ -727,14 +733,14 @@
static void PostCallRecordCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDebugReportCallbackEXT *pCallback) {
- CreateObject(instance, *pCallback, kVulkanObjectTypeDebugReportCallbackEXT, pAllocator);
+ InstanceCreateObject(instance, *pCallback, kVulkanObjectTypeDebugReportCallbackEXT, pAllocator);
}
VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance,
const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDebugReportCallbackEXT *pCallback) {
- auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
VkResult result =
instance_data->instance_dispatch_table.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
if (VK_SUCCESS == result) {
@@ -746,15 +752,15 @@
static bool PreCallValidateDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
const VkAllocationCallbacks *pAllocator) {
- bool skip = ValidateDestroyObject(instance, msgCallback, kVulkanObjectTypeDebugReportCallbackEXT, pAllocator,
- "VUID-vkDestroyDebugReportCallbackEXT-instance-01242",
- "VUID-vkDestroyDebugReportCallbackEXT-instance-01243");
+ bool skip = InstanceValidateDestroyObject(instance, msgCallback, kVulkanObjectTypeDebugReportCallbackEXT, pAllocator,
+ "VUID-vkDestroyDebugReportCallbackEXT-instance-01242",
+ "VUID-vkDestroyDebugReportCallbackEXT-instance-01243");
return skip;
}
static void PreCallRecordDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
const VkAllocationCallbacks *pAllocator) {
- RecordDestroyObject(instance, msgCallback, kVulkanObjectTypeDebugReportCallbackEXT);
+ InstanceRecordDestroyObject(instance, msgCallback, kVulkanObjectTypeDebugReportCallbackEXT);
}
VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
@@ -765,7 +771,7 @@
if (skip) return;
PreCallRecordDestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
}
- auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
instance_data->instance_dispatch_table.DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
layer_destroy_report_callback(instance_data->report_data, msgCallback, pAllocator);
}
@@ -773,7 +779,7 @@
VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
- auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
instance_data->instance_dispatch_table.DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix,
pMsg);
}
@@ -781,8 +787,8 @@
// VK_EXT_debug_utils commands
static bool PreCallValidateSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) {
- return ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkSetDebugUtilsObjectNameEXT-device-parameter",
- kVUIDUndefined);
+ return DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false,
+ "VUID-vkSetDebugUtilsObjectNameEXT-device-parameter", kVUIDUndefined);
}
VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) {
@@ -805,8 +811,8 @@
}
static bool PreCallValidateSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) {
- return ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkSetDebugUtilsObjectTagEXT-device-parameter",
- kVUIDUndefined);
+ return DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkSetDebugUtilsObjectTagEXT-device-parameter",
+ kVUIDUndefined);
}
VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) {
@@ -821,8 +827,8 @@
}
static bool PreCallValidateQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) {
- return ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueBeginDebugUtilsLabelEXT-queue-parameter",
- kVUIDUndefined);
+ return DeviceValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueBeginDebugUtilsLabelEXT-queue-parameter",
+ kVUIDUndefined);
}
VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) {
@@ -837,8 +843,8 @@
}
static bool PreCallValidateQueueEndDebugUtilsLabelEXT(VkQueue queue) {
- return ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueEndDebugUtilsLabelEXT-queue-parameter",
- kVUIDUndefined);
+ return DeviceValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueEndDebugUtilsLabelEXT-queue-parameter",
+ kVUIDUndefined);
}
VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(VkQueue queue) {
@@ -856,8 +862,8 @@
}
static bool PreCallValidateQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) {
- return ValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueInsertDebugUtilsLabelEXT-queue-parameter",
- kVUIDUndefined);
+ return DeviceValidateObject(queue, queue, kVulkanObjectTypeQueue, false, "VUID-vkQueueInsertDebugUtilsLabelEXT-queue-parameter",
+ kVUIDUndefined);
}
VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) {
@@ -875,8 +881,8 @@
}
static bool PreCallValidateCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) {
- return ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false,
- "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-parameter", kVUIDUndefined);
+ return DeviceValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false,
+ "VUID-vkCmdBeginDebugUtilsLabelEXT-commandBuffer-parameter", kVUIDUndefined);
}
VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) {
@@ -894,8 +900,8 @@
}
static bool PreCallValidateCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {
- return ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false,
- "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter", kVUIDUndefined);
+ return DeviceValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false,
+ "VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-parameter", kVUIDUndefined);
}
VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {
@@ -913,8 +919,8 @@
}
static bool PreCallValidateCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) {
- return ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false,
- "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-parameter", kVUIDUndefined);
+ return DeviceValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false,
+ "VUID-vkCmdInsertDebugUtilsLabelEXT-commandBuffer-parameter", kVUIDUndefined);
}
VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) {
@@ -934,14 +940,14 @@
static bool PreCallValidateCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDebugUtilsMessengerEXT *pMessenger) {
- return ValidateObject(instance, instance, kVulkanObjectTypeInstance, false,
- "VUID-vkCreateDebugUtilsMessengerEXT-instance-parameter", kVUIDUndefined);
+ return InstanceValidateObject(instance, instance, kVulkanObjectTypeInstance, false,
+ "VUID-vkCreateDebugUtilsMessengerEXT-instance-parameter", kVUIDUndefined);
}
static void PostCallRecordCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDebugUtilsMessengerEXT *pMessenger) {
- CreateObject(instance, *pMessenger, kVulkanObjectTypeDebugUtilsMessengerEXT, pAllocator);
+ InstanceCreateObject(instance, *pMessenger, kVulkanObjectTypeDebugUtilsMessengerEXT, pAllocator);
}
VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(VkInstance instance,
@@ -953,7 +959,7 @@
bool skip = PreCallValidateCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
}
- auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
VkResult result =
instance_data->instance_dispatch_table.CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
if (VK_SUCCESS == result) {
@@ -966,20 +972,20 @@
static bool PreCallValidateDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger,
const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false,
- "VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter", kVUIDUndefined);
- skip |= ValidateObject(instance, messenger, kVulkanObjectTypeDebugUtilsMessengerEXT, false,
- "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parameter",
- "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parent");
- skip |= ValidateDestroyObject(instance, messenger, kVulkanObjectTypeDebugUtilsMessengerEXT, pAllocator,
- "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01915",
- "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01916");
+ skip |= InstanceValidateObject(instance, instance, kVulkanObjectTypeInstance, false,
+ "VUID-vkDestroyDebugUtilsMessengerEXT-instance-parameter", kVUIDUndefined);
+ skip |= InstanceValidateObject(instance, messenger, kVulkanObjectTypeDebugUtilsMessengerEXT, false,
+ "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parameter",
+ "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-parent");
+ skip |= InstanceValidateDestroyObject(instance, messenger, kVulkanObjectTypeDebugUtilsMessengerEXT, pAllocator,
+ "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01915",
+ "VUID-vkDestroyDebugUtilsMessengerEXT-messenger-01916");
return skip;
}
static void PreCallRecordDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger,
const VkAllocationCallbacks *pAllocator) {
- RecordDestroyObject(instance, messenger, kVulkanObjectTypeDebugUtilsMessengerEXT);
+ InstanceRecordDestroyObject(instance, messenger, kVulkanObjectTypeDebugUtilsMessengerEXT);
}
VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger,
@@ -990,7 +996,7 @@
if (skip) return;
PreCallRecordDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
}
- auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
instance_data->instance_dispatch_table.DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
layer_destroy_messenger_callback(instance_data->report_data, messenger, pAllocator);
}
@@ -999,8 +1005,8 @@
VkDebugUtilsMessageTypeFlagsEXT messageTypes,
const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) {
bool skip = false;
- skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, false,
- "VUID-vkeSubmitDebugUtilsMessageEXT-instance-parameter", kVUIDUndefined);
+ skip |= InstanceValidateObject(instance, instance, kVulkanObjectTypeInstance, false,
+ "VUID-vkeSubmitDebugUtilsMessageEXT-instance-parameter", kVUIDUndefined);
return skip;
}
@@ -1013,7 +1019,7 @@
if (skip) return;
}
- auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
instance_data->instance_dispatch_table.SubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData);
}
@@ -1032,8 +1038,8 @@
static bool PreCallValidateEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
VkLayerProperties *pProperties) {
// Set null_allowed to true here to cover for the lame loader-layer interface wrapper calls
- return ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, true,
- "VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter", kVUIDUndefined);
+ return InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, true,
+ "VUID-vkEnumerateDeviceLayerProperties-physicalDevice-parameter", kVUIDUndefined);
}
VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
@@ -1057,8 +1063,8 @@
static bool PreCallValidateEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName,
uint32_t *pCount, VkExtensionProperties *pProperties) {
// Set null_allowed to true here to cover for the lame loader-layer interface wrapper calls
- return ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, true,
- "VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter", kVUIDUndefined);
+ return InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, true,
+ "VUID-vkEnumerateDeviceExtensionProperties-physicalDevice-parameter", kVUIDUndefined);
}
VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName,
@@ -1070,20 +1076,20 @@
}
if (pLayerName && !strcmp(pLayerName, globalLayerProps.layerName))
return util_GetExtensionProperties(0, nullptr, pCount, pProperties);
- auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
return instance_data->instance_dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
}
static bool PreCallValidateCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
- return ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkCreateDevice-physicalDevice-parameter", kVUIDUndefined);
+ return InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkCreateDevice-physicalDevice-parameter", kVUIDUndefined);
}
static void PostCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
- layer_data *phy_dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
- CreateObject(phy_dev_data->instance, *pDevice, kVulkanObjectTypeDevice, pAllocator);
+ instance_layer_data *phy_dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ InstanceCreateObject(phy_dev_data->instance, *pDevice, kVulkanObjectTypeDevice, pAllocator);
}
VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
@@ -1092,7 +1098,7 @@
bool skip = PreCallValidateCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
- layer_data *phy_dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
+ instance_layer_data *phy_dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
assert(chain_info->u.pLayerInfo);
@@ -1122,7 +1128,7 @@
// Add link back to physDev
device_data->physical_device = physicalDevice;
- device_data->instance = phy_dev_data->instance;
+ device_data->instance_data = phy_dev_data;
PostCallRecordCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
@@ -1132,10 +1138,10 @@
static bool PreCallValidateGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount,
VkImage *pSwapchainImages) {
bool skip = false;
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetSwapchainImagesKHR-device-parameter",
- "VUID-vkGetSwapchainImagesKHR-commonparent");
- skip |= ValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false,
- "VUID-vkGetSwapchainImagesKHR-swapchain-parameter", "VUID-vkGetSwapchainImagesKHR-commonparent");
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetSwapchainImagesKHR-device-parameter",
+ "VUID-vkGetSwapchainImagesKHR-commonparent");
+ skip |= DeviceValidateObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, false,
+ "VUID-vkGetSwapchainImagesKHR-swapchain-parameter", "VUID-vkGetSwapchainImagesKHR-commonparent");
return skip;
}
@@ -1168,8 +1174,8 @@
static bool PreCallValidateCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout) {
bool skip = false;
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateDescriptorSetLayout-device-parameter",
- kVUIDUndefined);
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false,
+ "VUID-vkCreateDescriptorSetLayout-device-parameter", kVUIDUndefined);
if (pCreateInfo) {
if (pCreateInfo->pBindings) {
for (uint32_t binding_index = 0; binding_index < pCreateInfo->bindingCount; ++binding_index) {
@@ -1179,8 +1185,8 @@
if (binding.pImmutableSamplers && is_sampler_type) {
for (uint32_t index2 = 0; index2 < binding.descriptorCount; ++index2) {
const VkSampler sampler = binding.pImmutableSamplers[index2];
- skip |= ValidateObject(device, sampler, kVulkanObjectTypeSampler, false,
- "VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", kVUIDUndefined);
+ skip |= DeviceValidateObject(device, sampler, kVulkanObjectTypeSampler, false,
+ "VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", kVUIDUndefined);
}
}
}
@@ -1191,7 +1197,7 @@
static void PostCallRecordCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout) {
- CreateObject(device, *pSetLayout, kVulkanObjectTypeDescriptorSetLayout, pAllocator);
+ DeviceCreateObject(device, *pSetLayout, kVulkanObjectTypeDescriptorSetLayout, pAllocator);
}
VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
@@ -1217,9 +1223,9 @@
for (uint32_t index1 = 0; index1 < pCreateInfo->bindingCount; ++index1) {
for (uint32_t index2 = 0; index2 < pCreateInfo->pBindings[index1].descriptorCount; ++index2) {
if (pCreateInfo->pBindings[index1].pImmutableSamplers) {
- skip |=
- ValidateObject(device, pCreateInfo->pBindings[index1].pImmutableSamplers[index2], kVulkanObjectTypeSampler,
- true, "VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", kVUIDUndefined);
+ skip |= DeviceValidateObject(device, pCreateInfo->pBindings[index1].pImmutableSamplers[index2],
+ kVulkanObjectTypeSampler, true,
+ "VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", kVUIDUndefined);
}
}
}
@@ -1229,8 +1235,8 @@
static bool PreCallValidateGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
VkDescriptorSetLayoutSupport *pSupport) {
- bool skip = ValidateObject(device, device, kVulkanObjectTypeDevice, false,
- "VUID-vkGetDescriptorSetLayoutSupport-device-parameter", kVUIDUndefined);
+ bool skip = DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false,
+ "VUID-vkGetDescriptorSetLayoutSupport-device-parameter", kVUIDUndefined);
if (pCreateInfo) {
skip |= ValidateSamplerObjects(device, pCreateInfo);
}
@@ -1251,8 +1257,8 @@
static bool PreCallValidateGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
VkDescriptorSetLayoutSupport *pSupport) {
- bool skip = ValidateObject(device, device, kVulkanObjectTypeDevice, false,
- "VUID-vkGetDescriptorSetLayoutSupportKHR-device-parameter", kVUIDUndefined);
+ bool skip = DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false,
+ "VUID-vkGetDescriptorSetLayoutSupportKHR-device-parameter", kVUIDUndefined);
if (pCreateInfo) {
skip |= ValidateSamplerObjects(device, pCreateInfo);
}
@@ -1274,20 +1280,20 @@
static bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties *pQueueFamilyProperties) {
- bool skip = ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter", kVUIDUndefined);
+ bool skip = InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter", kVUIDUndefined);
return skip;
}
static void PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties *pQueueFamilyProperties) {
if (pQueueFamilyProperties != NULL) {
- auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
- if (instance_data->queue_family_properties.size() < *pQueueFamilyPropertyCount) {
- instance_data->queue_family_properties.resize(*pQueueFamilyPropertyCount);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ if (instance_data->objdata.queue_family_properties.size() < *pQueueFamilyPropertyCount) {
+ instance_data->objdata.queue_family_properties.resize(*pQueueFamilyPropertyCount);
}
for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) {
- instance_data->queue_family_properties[i] = pQueueFamilyProperties[i];
+ instance_data->objdata.queue_family_properties[i] = pQueueFamilyProperties[i];
}
}
}
@@ -1303,7 +1309,7 @@
}
if (skip) return;
- auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
instance_data->instance_dispatch_table.GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount,
pQueueFamilyProperties);
std::lock_guard<std::mutex> lock(global_lock);
@@ -1312,7 +1318,7 @@
static void PostCallRecordCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
VkInstance *pInstance) {
- CreateObject(*pInstance, *pInstance, kVulkanObjectTypeInstance, pAllocator);
+ InstanceCreateObject(*pInstance, *pInstance, kVulkanObjectTypeInstance, pAllocator);
}
VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
@@ -1334,7 +1340,7 @@
return result;
}
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(*pInstance), instance_layer_data_map);
instance_data->instance = *pInstance;
layer_init_instance_dispatch_table(*pInstance, &instance_data->instance_dispatch_table, fpGetInstanceProcAddr);
@@ -1357,15 +1363,15 @@
}
static bool PreCallValidateEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
VkPhysicalDevice *pPhysicalDevices) {
- bool skip = ValidateObject(instance, instance, kVulkanObjectTypeInstance, false,
- "VUID-vkEnumeratePhysicalDevices-instance-parameter", kVUIDUndefined);
+ bool skip = InstanceValidateObject(instance, instance, kVulkanObjectTypeInstance, false,
+ "VUID-vkEnumeratePhysicalDevices-instance-parameter", kVUIDUndefined);
return skip;
}
static void PostCallRecordEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
VkPhysicalDevice *pPhysicalDevices) {
if (pPhysicalDevices) {
for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) {
- CreateObject(instance, pPhysicalDevices[i], kVulkanObjectTypePhysicalDevice, nullptr);
+ InstanceCreateObject(instance, pPhysicalDevices[i], kVulkanObjectTypePhysicalDevice, nullptr);
}
}
}
@@ -1379,7 +1385,7 @@
}
if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
VkResult result =
instance_data->instance_dispatch_table.EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
@@ -1393,10 +1399,10 @@
static bool PreCallValidateAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo,
VkCommandBuffer *pCommandBuffers) {
bool skip = false;
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkAllocateCommandBuffers-device-parameter",
- kVUIDUndefined);
- skip |= ValidateObject(device, pAllocateInfo->commandPool, kVulkanObjectTypeCommandPool, false,
- "VUID-VkCommandBufferAllocateInfo-commandPool-parameter", kVUIDUndefined);
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkAllocateCommandBuffers-device-parameter",
+ kVUIDUndefined);
+ skip |= DeviceValidateObject(device, pAllocateInfo->commandPool, kVulkanObjectTypeCommandPool, false,
+ "VUID-VkCommandBufferAllocateInfo-commandPool-parameter", kVUIDUndefined);
return skip;
}
@@ -1429,15 +1435,15 @@
static bool PreCallValidateAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo,
VkDescriptorSet *pDescriptorSets) {
bool skip = false;
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkAllocateDescriptorSets-device-parameter",
- kVUIDUndefined);
- skip |= ValidateObject(device, pAllocateInfo->descriptorPool, kVulkanObjectTypeDescriptorPool, false,
- "VUID-VkDescriptorSetAllocateInfo-descriptorPool-parameter",
- "VUID-VkDescriptorSetAllocateInfo-commonparent");
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkAllocateDescriptorSets-device-parameter",
+ kVUIDUndefined);
+ skip |= DeviceValidateObject(device, pAllocateInfo->descriptorPool, kVulkanObjectTypeDescriptorPool, false,
+ "VUID-VkDescriptorSetAllocateInfo-descriptorPool-parameter",
+ "VUID-VkDescriptorSetAllocateInfo-commonparent");
for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
- skip |= ValidateObject(device, pAllocateInfo->pSetLayouts[i], kVulkanObjectTypeDescriptorSetLayout, false,
- "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter",
- "VUID-VkDescriptorSetAllocateInfo-commonparent");
+ skip |= DeviceValidateObject(device, pAllocateInfo->pSetLayouts[i], kVulkanObjectTypeDescriptorSetLayout, false,
+ "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter",
+ "VUID-VkDescriptorSetAllocateInfo-commonparent");
}
return skip;
}
@@ -1472,15 +1478,15 @@
static bool PreCallValidateFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
const VkCommandBuffer *pCommandBuffers) {
bool skip = false;
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkFreeCommandBuffers-device-parameter",
- kVUIDUndefined);
- skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false,
- "VUID-vkFreeCommandBuffers-commandPool-parameter", "VUID-vkFreeCommandBuffers-commandPool-parent");
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkFreeCommandBuffers-device-parameter",
+ kVUIDUndefined);
+ skip |= DeviceValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, false,
+ "VUID-vkFreeCommandBuffers-commandPool-parameter", "VUID-vkFreeCommandBuffers-commandPool-parent");
for (uint32_t i = 0; i < commandBufferCount; i++) {
if (pCommandBuffers[i] != VK_NULL_HANDLE) {
skip |= ValidateCommandBuffer(device, commandPool, pCommandBuffers[i]);
- skip |= ValidateDestroyObject(device, pCommandBuffers[i], kVulkanObjectTypeCommandBuffer, nullptr, kVUIDUndefined,
- kVUIDUndefined);
+ skip |= DeviceValidateDestroyObject(device, pCommandBuffers[i], kVulkanObjectTypeCommandBuffer, nullptr, kVUIDUndefined,
+ kVUIDUndefined);
}
}
return skip;
@@ -1489,7 +1495,7 @@
static void PreCallRecordFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
const VkCommandBuffer *pCommandBuffers) {
for (uint32_t i = 0; i < commandBufferCount; i++) {
- RecordDestroyObject(device, pCommandBuffers[i], kVulkanObjectTypeCommandBuffer);
+ DeviceRecordDestroyObject(device, pCommandBuffers[i], kVulkanObjectTypeCommandBuffer);
}
}
@@ -1507,20 +1513,20 @@
}
static bool PreCallValidateDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
- return ValidateDestroyObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, pAllocator,
- "VUID-vkDestroySwapchainKHR-swapchain-01283", "VUID-vkDestroySwapchainKHR-swapchain-01284");
+ return DeviceValidateDestroyObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, pAllocator,
+ "VUID-vkDestroySwapchainKHR-swapchain-01283", "VUID-vkDestroySwapchainKHR-swapchain-01284");
}
static void PreCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
- RecordDestroyObject(device, swapchain, kVulkanObjectTypeSwapchainKHR);
+ DeviceRecordDestroyObject(device, swapchain, kVulkanObjectTypeSwapchainKHR);
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- std::unordered_map<uint64_t, ObjTrackState *>::iterator itr = device_data->swapchainImageMap.begin();
- while (itr != device_data->swapchainImageMap.end()) {
+ std::unordered_map<uint64_t, ObjTrackState *>::iterator itr = device_data->objdata.swapchainImageMap.begin();
+ while (itr != device_data->objdata.swapchainImageMap.end()) {
ObjTrackState *pNode = (*itr).second;
if (pNode->parent_object == HandleToUint64(swapchain)) {
delete pNode;
auto delete_item = itr++;
- device_data->swapchainImageMap.erase(delete_item);
+ device_data->objdata.swapchainImageMap.erase(delete_item);
} else {
++itr;
}
@@ -1542,15 +1548,16 @@
static bool PreCallValidateFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount,
const VkDescriptorSet *pDescriptorSets) {
bool skip = false;
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkFreeDescriptorSets-device-parameter",
- kVUIDUndefined);
- skip |= ValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, false,
- "VUID-vkFreeDescriptorSets-descriptorPool-parameter", "VUID-vkFreeDescriptorSets-descriptorPool-parent");
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkFreeDescriptorSets-device-parameter",
+ kVUIDUndefined);
+ skip |= DeviceValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, false,
+ "VUID-vkFreeDescriptorSets-descriptorPool-parameter",
+ "VUID-vkFreeDescriptorSets-descriptorPool-parent");
for (uint32_t i = 0; i < descriptorSetCount; i++) {
if (pDescriptorSets[i] != VK_NULL_HANDLE) {
skip |= ValidateDescriptorSet(device, descriptorPool, pDescriptorSets[i]);
- skip |= ValidateDestroyObject(device, pDescriptorSets[i], kVulkanObjectTypeDescriptorSet, nullptr, kVUIDUndefined,
- kVUIDUndefined);
+ skip |= DeviceValidateDestroyObject(device, pDescriptorSets[i], kVulkanObjectTypeDescriptorSet, nullptr, kVUIDUndefined,
+ kVUIDUndefined);
}
}
return skip;
@@ -1558,7 +1565,7 @@
static void PreCallRecordFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount,
const VkDescriptorSet *pDescriptorSets) {
for (uint32_t i = 0; i < descriptorSetCount; i++) {
- RecordDestroyObject(device, pDescriptorSets[i], kVulkanObjectTypeDescriptorSet);
+ DeviceRecordDestroyObject(device, pDescriptorSets[i], kVulkanObjectTypeDescriptorSet);
}
}
@@ -1579,37 +1586,39 @@
const VkAllocationCallbacks *pAllocator) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyDescriptorPool-device-parameter",
- kVUIDUndefined);
- skip |= ValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, true,
- "VUID-vkDestroyDescriptorPool-descriptorPool-parameter",
- "VUID-vkDestroyDescriptorPool-descriptorPool-parent");
- std::unordered_map<uint64_t, ObjTrackState *>::iterator itr = device_data->object_map[kVulkanObjectTypeDescriptorSet].begin();
- while (itr != device_data->object_map[kVulkanObjectTypeDescriptorSet].end()) {
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyDescriptorPool-device-parameter",
+ kVUIDUndefined);
+ skip |= DeviceValidateObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, true,
+ "VUID-vkDestroyDescriptorPool-descriptorPool-parameter",
+ "VUID-vkDestroyDescriptorPool-descriptorPool-parent");
+ std::unordered_map<uint64_t, ObjTrackState *>::iterator itr =
+ device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet].begin();
+ while (itr != device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet].end()) {
ObjTrackState *pNode = (*itr).second;
auto del_itr = itr++;
if (pNode->parent_object == HandleToUint64(descriptorPool)) {
- skip |= ValidateDestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet, nullptr,
- kVUIDUndefined, kVUIDUndefined);
+ skip |= DeviceValidateDestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet,
+ nullptr, kVUIDUndefined, kVUIDUndefined);
}
}
- skip |= ValidateDestroyObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, pAllocator,
- "VUID-vkDestroyDescriptorPool-descriptorPool-00304",
- "VUID-vkDestroyDescriptorPool-descriptorPool-00305");
+ skip |= DeviceValidateDestroyObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, pAllocator,
+ "VUID-vkDestroyDescriptorPool-descriptorPool-00304",
+ "VUID-vkDestroyDescriptorPool-descriptorPool-00305");
return skip;
}
static void PreCallRecordDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
const VkAllocationCallbacks *pAllocator) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- std::unordered_map<uint64_t, ObjTrackState *>::iterator itr = device_data->object_map[kVulkanObjectTypeDescriptorSet].begin();
- while (itr != device_data->object_map[kVulkanObjectTypeDescriptorSet].end()) {
+ std::unordered_map<uint64_t, ObjTrackState *>::iterator itr =
+ device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet].begin();
+ while (itr != device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet].end()) {
ObjTrackState *pNode = (*itr).second;
auto del_itr = itr++;
if (pNode->parent_object == HandleToUint64(descriptorPool)) {
- RecordDestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet);
+ DeviceRecordDestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet);
}
}
- RecordDestroyObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool);
+ DeviceRecordDestroyObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool);
}
VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
@@ -1628,39 +1637,40 @@
static bool PreCallValidateDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
- skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyCommandPool-device-parameter",
- kVUIDUndefined);
- skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, true,
- "VUID-vkDestroyCommandPool-commandPool-parameter", "VUID-vkDestroyCommandPool-commandPool-parent");
- auto itr = device_data->object_map[kVulkanObjectTypeCommandBuffer].begin();
+ skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyCommandPool-device-parameter",
+ kVUIDUndefined);
+ skip |= DeviceValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, true,
+ "VUID-vkDestroyCommandPool-commandPool-parameter", "VUID-vkDestroyCommandPool-commandPool-parent");
+ auto itr = device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer].begin();
auto del_itr = itr;
- while (itr != device_data->object_map[kVulkanObjectTypeCommandBuffer].end()) {
+ while (itr != device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer].end()) {
ObjTrackState *pNode = (*itr).second;
del_itr = itr++;
if (pNode->parent_object == HandleToUint64(commandPool)) {
skip |= ValidateCommandBuffer(device, commandPool, reinterpret_cast<VkCommandBuffer>((*del_itr).first));
- skip |= ValidateDestroyObject(device, reinterpret_cast<VkCommandBuffer>((*del_itr).first),
- kVulkanObjectTypeCommandBuffer, nullptr, kVUIDUndefined, kVUIDUndefined);
+ skip |= DeviceValidateDestroyObject(device, reinterpret_cast<VkCommandBuffer>((*del_itr).first),
+ kVulkanObjectTypeCommandBuffer, nullptr, kVUIDUndefined, kVUIDUndefined);
}
}
- skip |= ValidateDestroyObject(device, commandPool, kVulkanObjectTypeCommandPool, pAllocator,
- "VUID-vkDestroyCommandPool-commandPool-00042", "VUID-vkDestroyCommandPool-commandPool-00043");
+ skip |=
+ DeviceValidateDestroyObject(device, commandPool, kVulkanObjectTypeCommandPool, pAllocator,
+ "VUID-vkDestroyCommandPool-commandPool-00042", "VUID-vkDestroyCommandPool-commandPool-00043");
return skip;
}
static void PreCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- auto itr = device_data->object_map[kVulkanObjectTypeCommandBuffer].begin();
+ auto itr = device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer].begin();
auto del_itr = itr;
// A CommandPool's cmd buffers are implicitly deleted when pool is deleted. Remove this pool's cmdBuffers from cmd buffer map.
- while (itr != device_data->object_map[kVulkanObjectTypeCommandBuffer].end()) {
+ while (itr != device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer].end()) {
ObjTrackState *pNode = (*itr).second;
del_itr = itr++;
if (pNode->parent_object == HandleToUint64(commandPool)) {
- RecordDestroyObject(device, reinterpret_cast<VkCommandBuffer>((*del_itr).first), kVulkanObjectTypeCommandBuffer);
+ DeviceRecordDestroyObject(device, reinterpret_cast<VkCommandBuffer>((*del_itr).first), kVulkanObjectTypeCommandBuffer);
}
}
- RecordDestroyObject(device, commandPool, kVulkanObjectTypeCommandPool);
+ DeviceRecordDestroyObject(device, commandPool, kVulkanObjectTypeCommandPool);
}
VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) {
@@ -1678,20 +1688,20 @@
static bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
- return ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter", kVUIDUndefined);
+ return InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter", kVUIDUndefined);
}
static void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
if (pQueueFamilyProperties != NULL) {
- if (instance_data->queue_family_properties.size() < *pQueueFamilyPropertyCount) {
- instance_data->queue_family_properties.resize(*pQueueFamilyPropertyCount);
+ if (instance_data->objdata.queue_family_properties.size() < *pQueueFamilyPropertyCount) {
+ instance_data->objdata.queue_family_properties.resize(*pQueueFamilyPropertyCount);
}
for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) {
- instance_data->queue_family_properties[i] = pQueueFamilyProperties[i].queueFamilyProperties;
+ instance_data->objdata.queue_family_properties[i] = pQueueFamilyProperties[i].queueFamilyProperties;
}
}
}
@@ -1706,7 +1716,7 @@
pQueueFamilyProperties);
}
if (skip) return;
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
instance_data->instance_dispatch_table.GetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount,
pQueueFamilyProperties);
std::lock_guard<std::mutex> lock(global_lock);
@@ -1723,7 +1733,7 @@
pQueueFamilyProperties);
}
if (skip) return;
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
instance_data->instance_dispatch_table.GetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount,
pQueueFamilyProperties);
std::lock_guard<std::mutex> lock(global_lock);
@@ -1732,8 +1742,8 @@
static bool PreCallValidateGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
VkDisplayPropertiesKHR *pProperties) {
- bool skip = ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter", kVUIDUndefined);
+ bool skip = InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter", kVUIDUndefined);
return skip;
}
@@ -1741,7 +1751,7 @@
VkDisplayPropertiesKHR *pProperties) {
if (pProperties) {
for (uint32_t i = 0; i < *pPropertyCount; ++i) {
- CreateObject(physicalDevice, pProperties[i].display, kVulkanObjectTypeDisplayKHR, nullptr);
+ InstanceCreateObject(physicalDevice, pProperties[i].display, kVulkanObjectTypeDisplayKHR, nullptr);
}
}
}
@@ -1755,7 +1765,7 @@
}
if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
VkResult result =
instance_data->instance_dispatch_table.GetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
@@ -1769,10 +1779,10 @@
static bool PreCallValidateGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) {
bool skip = false;
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter", kVUIDUndefined);
- skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false,
- "VUID-vkGetDisplayModePropertiesKHR-display-parameter", kVUIDUndefined);
+ skip |= InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter", kVUIDUndefined);
+ skip |= InstanceValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false,
+ "VUID-vkGetDisplayModePropertiesKHR-display-parameter", kVUIDUndefined);
return skip;
}
@@ -1781,7 +1791,7 @@
uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) {
if (pProperties) {
for (uint32_t i = 0; i < *pPropertyCount; ++i) {
- CreateObject(physicalDevice, pProperties[i].displayMode, kVulkanObjectTypeDisplayModeKHR, nullptr);
+ InstanceCreateObject(physicalDevice, pProperties[i].displayMode, kVulkanObjectTypeDisplayModeKHR, nullptr);
}
}
}
@@ -1795,7 +1805,7 @@
}
if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
VkResult result =
instance_data->instance_dispatch_table.GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
@@ -1809,8 +1819,8 @@
}
static bool PreCallValidateDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) {
- return ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDebugMarkerSetObjectNameEXT-device-parameter",
- kVUIDUndefined);
+ return DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false,
+ "VUID-vkDebugMarkerSetObjectNameEXT-device-parameter", kVUIDUndefined);
}
VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) {
@@ -1833,7 +1843,7 @@
// This is not a Vulkan API, but is part of the loader-layer interface.
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
if (instance_data->instance_dispatch_table.GetPhysicalDeviceProcAddr == NULL) {
return NULL;
}
@@ -1841,8 +1851,8 @@
}
static bool PreCallValidateGetDeviceProcAddr(VkDevice device, const char *funcName) {
- return ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceProcAddr-device-parameter",
- kVUIDUndefined);
+ return DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceProcAddr-device-parameter",
+ kVUIDUndefined);
}
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) {
@@ -1864,8 +1874,8 @@
}
static bool PreCallValidateGetInstanceProcAddr(VkInstance instance, const char *funcName) {
- return ValidateObject(instance, instance, kVulkanObjectTypeInstance, false, "VUID-vkGetInstanceProcAddr-instance-parameter",
- kVUIDUndefined);
+ return InstanceValidateObject(instance, instance, kVulkanObjectTypeInstance, false,
+ "VUID-vkGetInstanceProcAddr-instance-parameter", kVUIDUndefined);
}
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) {
@@ -1878,21 +1888,21 @@
if (item != name_to_funcptr_map.end()) {
return reinterpret_cast<PFN_vkVoidFunction>(item->second);
}
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
if (!instance_data->instance_dispatch_table.GetInstanceProcAddr) return nullptr;
return instance_data->instance_dispatch_table.GetInstanceProcAddr(instance, funcName);
}
static bool PreCallValidateGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
VkDisplayProperties2KHR *pProperties) {
- return ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-physicalDevice-parameter", kVUIDUndefined);
+ return InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-physicalDevice-parameter", kVUIDUndefined);
}
static void PostCallRecordGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
VkDisplayProperties2KHR *pProperties) {
for (uint32_t index = 0; index < *pPropertyCount; ++index) {
- CreateObject(physicalDevice, pProperties[index].displayProperties.display, kVulkanObjectTypeDisplayKHR, nullptr);
+ InstanceCreateObject(physicalDevice, pProperties[index].displayProperties.display, kVulkanObjectTypeDisplayKHR, nullptr);
}
}
@@ -1903,7 +1913,7 @@
bool skip = PreCallValidateGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties);
if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
VkResult result =
instance_data->instance_dispatch_table.GetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties);
if (pProperties && (VK_SUCCESS == result || VK_INCOMPLETE == result)) {
@@ -1916,14 +1926,14 @@
static bool PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) {
- return ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter", kVUIDUndefined);
+ return InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetDisplayPlaneSupportedDisplaysKHR-physicalDevice-parameter", kVUIDUndefined);
}
static void PostCallRecordGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) {
for (uint32_t index = 0; index < *pDisplayCount; ++index) {
- CreateObject(physicalDevice, pDisplays[index], kVulkanObjectTypeDisplayKHR, nullptr);
+ InstanceCreateObject(physicalDevice, pDisplays[index], kVulkanObjectTypeDisplayKHR, nullptr);
}
}
@@ -1934,7 +1944,7 @@
bool skip = PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays);
if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
VkResult result = instance_data->instance_dispatch_table.GetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex,
pDisplayCount, pDisplays);
if (pDisplays && (VK_SUCCESS == result || VK_INCOMPLETE == result)) {
@@ -1947,18 +1957,18 @@
static bool PreCallValidateGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties) {
bool skip = false;
- skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetDisplayModeProperties2KHR-physicalDevice-parameter", kVUIDUndefined);
- skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false,
- "VUID-vkGetDisplayModeProperties2KHR-display-parameter", kVUIDUndefined);
+ skip |= InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetDisplayModeProperties2KHR-physicalDevice-parameter", kVUIDUndefined);
+ skip |= InstanceValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false,
+ "VUID-vkGetDisplayModeProperties2KHR-display-parameter", kVUIDUndefined);
return skip;
}
static void PostCallRecordGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties) {
for (uint32_t index = 0; index < *pPropertyCount; ++index) {
- CreateObject(physicalDevice, pProperties[index].displayModeProperties.displayMode, kVulkanObjectTypeDisplayModeKHR,
- nullptr);
+ InstanceCreateObject(physicalDevice, pProperties[index].displayModeProperties.displayMode, kVulkanObjectTypeDisplayModeKHR,
+ nullptr);
}
}
@@ -1969,7 +1979,7 @@
bool skip = PreCallValidateGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties);
if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
VkResult result =
instance_data->instance_dispatch_table.GetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties);
if (pProperties && (VK_SUCCESS == result || VK_INCOMPLETE == result)) {
diff --git a/scripts/object_tracker_generator.py b/scripts/object_tracker_generator.py
index f08c42c..ed923a7 100644
--- a/scripts/object_tracker_generator.py
+++ b/scripts/object_tracker_generator.py
@@ -702,7 +702,13 @@
create_obj_code += '%sfor (uint32_t index = 0; index < %s; index++) {\n' % (indent, cmd_info[-1].len)
indent = self.incIndent(indent)
object_dest = '%s[index]' % cmd_info[-1].name
- create_obj_code += '%sCreateObject(%s, %s, %s, %s);\n' % (indent, params[0].find('name').text, object_dest, self.GetVulkanObjType(cmd_info[-1].type), allocator)
+
+ dispobj = params[0].find('type').text
+ calltype = 'Device'
+ if dispobj == 'VkInstance' or dispobj == 'VkPhysicalDevice':
+ calltype = 'Instance'
+
+ create_obj_code += '%s%sCreateObject(%s, %s, %s, %s);\n' % (indent, calltype, params[0].find('name').text, object_dest, self.GetVulkanObjType(cmd_info[-1].type), allocator)
if object_array == True:
indent = self.decIndent(indent)
create_obj_code += '%s}\n' % indent
@@ -730,9 +736,13 @@
# This API is freeing an array of handles -- add loop control
validate_code += 'HEY, NEED TO DESTROY AN ARRAY\n'
else:
+ dispobj = cmd_info[0].type
+ calltype = 'Device'
+ if dispobj == 'VkInstance' or dispobj == 'VkPhysicalDevice':
+ calltype = 'Instance'
# Call Destroy a single time
- validate_code += '%s skip |= ValidateDestroyObject(%s, %s, %s, pAllocator, %s, %s);\n' % (indent, cmd_info[0].name, cmd_info[param].name, self.GetVulkanObjType(cmd_info[param].type), compatalloc_vuid, nullalloc_vuid)
- record_code += '%s RecordDestroyObject(%s, %s, %s);\n' % (indent, cmd_info[0].name, cmd_info[param].name, self.GetVulkanObjType(cmd_info[param].type))
+ validate_code += '%s skip |= %sValidateDestroyObject(%s, %s, %s, pAllocator, %s, %s);\n' % (indent, calltype, cmd_info[0].name, cmd_info[param].name, self.GetVulkanObjType(cmd_info[param].type), compatalloc_vuid, nullalloc_vuid)
+ record_code += '%s %sRecordDestroyObject(%s, %s, %s);\n' % (indent, calltype, cmd_info[0].name, cmd_info[param].name, self.GetVulkanObjType(cmd_info[param].type))
return object_array, validate_code, record_code
#
# Output validation for a single object (obj_count is NULL) or a counted list of objects
@@ -746,14 +756,17 @@
# If no parent VUID for this member, look for a commonparent VUID
if parent_vuid == 'kVUIDUndefined':
parent_vuid = self.GetVuid(parent_name, 'commonparent')
+ calltype = 'Device'
+ if disp_name == 'instance' or disp_name == 'physicalDevice':
+ calltype = 'Instance'
if obj_count is not None:
pre_call_code += '%s for (uint32_t %s = 0; %s < %s; ++%s) {\n' % (indent, index, index, obj_count, index)
indent = self.incIndent(indent)
- pre_call_code += '%s skip |= ValidateObject(%s, %s%s[%s], %s, %s, %s, %s);\n' % (indent, disp_name, prefix, obj_name, index, self.GetVulkanObjType(obj_type), null_allowed, param_vuid, parent_vuid)
+ pre_call_code += '%s skip |= %sValidateObject(%s, %s%s[%s], %s, %s, %s, %s);\n' % (indent, calltype, disp_name, prefix, obj_name, index, self.GetVulkanObjType(obj_type), null_allowed, param_vuid, parent_vuid)
indent = self.decIndent(indent)
pre_call_code += '%s }\n' % indent
else:
- pre_call_code += '%s skip |= ValidateObject(%s, %s%s, %s, %s, %s, %s);\n' % (indent, disp_name, prefix, obj_name, self.GetVulkanObjType(obj_type), null_allowed, param_vuid, parent_vuid)
+ pre_call_code += '%s skip |= %sValidateObject(%s, %s%s, %s, %s, %s, %s);\n' % (indent, calltype, disp_name, prefix, obj_name, self.GetVulkanObjType(obj_type), null_allowed, param_vuid, parent_vuid)
return pre_call_code
#
# first_level_param indicates if elements are passed directly into the function else they're below a ptr/struct
@@ -1013,11 +1026,13 @@
# Use correct dispatch table
disp_name = cmdinfo.elem.find('param/name').text
disp_type = cmdinfo.elem.find('param/type').text
+ map_type = ''
if disp_type in ["VkInstance", "VkPhysicalDevice"] or cmdname == 'vkCreateInstance':
object_type = 'instance'
+ map_type = 'instance_'
else:
object_type = 'device'
- dispatch_table = 'GetLayerDataPtr(get_dispatch_key(%s), layer_data_map)->%s_dispatch_table.' % (disp_name, object_type)
+ dispatch_table = 'GetLayerDataPtr(get_dispatch_key(%s), %slayer_data_map)->%s_dispatch_table.' % (disp_name, map_type, object_type)
down_chain_call = fcn_call.replace('TOKEN', dispatch_table, 1)
self.appendSection('command', ' ' + assignresult + down_chain_call)