layers: Move chassis to data-in-the-object model
Includes supporting layer-chassis changes and conversion of
object-tracker validation object to this model.
Change-Id: I23868c5cc9ec67efdf969f3bdea5341df168ac03
diff --git a/layers/VkLayer_object_tracker.def b/layers/VkLayer_object_tracker.def
deleted file mode 100644
index 0ce5f47..0000000
--- a/layers/VkLayer_object_tracker.def
+++ /dev/null
@@ -1,30 +0,0 @@
-
-;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;
-; Copyright (c) 2015-2016 The Khronos Group Inc.
-; Copyright (c) 2015-2016 Valve Corporation
-; Copyright (c) 2015-2016 LunarG, Inc.
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS,
-; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-; See the License for the specific language governing permissions and
-; limitations under the License.
-;
-; Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
-;
-;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-LIBRARY VkLayer_object_tracker
-EXPORTS
-vkGetInstanceProcAddr
-vkGetDeviceProcAddr
-vkEnumerateInstanceLayerProperties
-vkEnumerateInstanceExtensionProperties
-vkNegotiateLoaderLayerInterfaceVersion
diff --git a/layers/interceptor_objects.h b/layers/interceptor_objects.h
deleted file mode 100644
index 88f13b5..0000000
--- a/layers/interceptor_objects.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "object_lifetime_validation.h"
diff --git a/layers/object_lifetime_validation.h b/layers/object_lifetime_validation.h
index 1b8db72..98dfa37 100644
--- a/layers/object_lifetime_validation.h
+++ b/layers/object_lifetime_validation.h
@@ -38,10 +38,51 @@
extern uint64_t object_track_index;
-class ObjectLifetimes : public layer_chassis {
+// Object Status -- used to track state of individual objects
+typedef VkFlags ObjectStatusFlags;
+enum ObjectStatusFlagBits {
+ OBJSTATUS_NONE = 0x00000000, // No status is set
+ OBJSTATUS_FENCE_IS_SUBMITTED = 0x00000001, // Fence has been submitted
+ OBJSTATUS_VIEWPORT_BOUND = 0x00000002, // Viewport state object has been bound
+ OBJSTATUS_RASTER_BOUND = 0x00000004, // Viewport state object has been bound
+ OBJSTATUS_COLOR_BLEND_BOUND = 0x00000008, // Viewport state object has been bound
+ OBJSTATUS_DEPTH_STENCIL_BOUND = 0x00000010, // Viewport state object has been bound
+ OBJSTATUS_GPU_MEM_MAPPED = 0x00000020, // Memory object is currently mapped
+ OBJSTATUS_COMMAND_BUFFER_SECONDARY = 0x00000040, // Command Buffer is of type SECONDARY
+ OBJSTATUS_CUSTOM_ALLOCATOR = 0x00000080, // Allocated with custom allocator
+};
+
+// Object and state information structure
+struct ObjTrackState {
+ uint64_t handle; // Object handle (new)
+ VulkanObjectType object_type; // Object type identifier
+ ObjectStatusFlags status; // Object state
+ uint64_t parent_object; // Parent object
+};
+
+// Track Queue information
+struct ObjTrackQueueInfo {
+ uint32_t queue_node_index;
+ VkQueue queue;
+};
+
+typedef std::unordered_map<uint64_t, ObjTrackState *> object_map_type;
+
+class ObjectLifetimes : public ValidationObject {
public:
- // Constructor for state_tracker
- ObjectLifetimes(){};
+ uint64_t num_objects[kVulkanObjectTypeMax + 1];
+ uint64_t num_total_objects;
+ // Vector of unordered_maps per object type to hold ObjTrackState info
+ std::vector<object_map_type> object_map;
+ // Special-case map for swapchain images
+ std::unordered_map<uint64_t, ObjTrackState *> swapchainImageMap;
+ // Map of queue information structures, one per queue
+ std::unordered_map<VkQueue, ObjTrackQueueInfo *> queue_info_map;
+
+ std::vector<VkQueueFamilyProperties> queue_family_properties;
+
+ // Constructor for object lifetime tracking
+ ObjectLifetimes() : num_objects{}, num_total_objects(0), object_map{} { object_map.resize(kVulkanObjectTypeMax + 1); }
bool DeviceReportUndestroyedObjects(VkDevice device, VulkanObjectType object_type, const std::string &error_code);
void DeviceDestroyUndestroyedObjects(VkDevice device, VulkanObjectType object_type);
@@ -62,51 +103,18 @@
template <typename DispObj>
bool ValidateDescriptorWrite(DispObj disp, VkWriteDescriptorSet const *desc, bool isPush);
- template <typename T1, typename T2>
- 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;
- }
- }
- }
+ ObjectLifetimes *GetObjectLifetimeData(std::vector<ValidationObject *> &object_dispatch) {
+ for (auto layer_object : object_dispatch) {
+ if (layer_object->container_type == LayerObjectTypeObjectTracker) {
+ return (reinterpret_cast<ObjectLifetimes *>(layer_object));
}
- // 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;
- }
+ return nullptr;
+ };
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) {
+ 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) {
if (null_allowed && (object == VK_NULL_HANDLE)) {
return false;
}
@@ -118,46 +126,49 @@
VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[object_type];
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
- // Look for object in device object map
- if (device_data->objdata.object_map[object_type].find(object_handle) ==
- device_data->objdata.object_map[object_type].end()) {
+ // Look for object in object map
+ if (object_map[object_type].find(object_handle) == 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->objdata.swapchainImageMap.find(object_handle) == device_data->objdata.swapchainImageMap.end())) {
+ if ((object_type != kVulkanObjectTypeImage) || (swapchainImageMap.find(object_handle) == 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->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);
- } else {
- return false;
+ for (auto layer_object_data : other_device_data.second->object_dispatch) {
+ if (layer_object_data->container_type == LayerObjectTypeObjectTracker) {
+ auto object_lifetime_data = reinterpret_cast<ObjectLifetimes *>(layer_object_data);
+ if (object_lifetime_data && (object_lifetime_data != this)) {
+ if (object_lifetime_data->object_map[object_type].find(object_handle) !=
+ object_lifetime_data->object_map[object_type].end() ||
+ (object_type == kVulkanObjectTypeImage &&
+ object_lifetime_data->swapchainImageMap.find(object_handle) !=
+ object_lifetime_data->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(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);
+ } else {
+ return false;
+ }
+ }
}
}
}
}
// 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);
+ return log_msg(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;
}
- 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)) {
+ template <typename T1, typename T2>
+ void CreateObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type, const VkAllocationCallbacks *pAllocator) {
+ uint64_t object_handle = HandleToUint64(object);
+ bool custom_allocator = (pAllocator != nullptr);
+ if (!object_map[object_type].count(object_handle)) {
VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[object_type];
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],
@@ -168,90 +179,61 @@
pNewObjNode->status = custom_allocator ? OBJSTATUS_CUSTOM_ALLOCATOR : OBJSTATUS_NONE;
pNewObjNode->handle = object_handle;
- obj_data->object_map[object_type][object_handle] = pNewObjNode;
- obj_data->num_objects[object_type]++;
- obj_data->num_total_objects++;
+ object_map[object_type][object_handle] = pNewObjNode;
+ num_objects[object_type]++;
+ num_total_objects++;
}
}
- template <typename T1, typename T2>
- 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>
- 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) {
+ void DestroyObjectSilently(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());
+ auto item = object_map[object_type].find(object_handle);
+ assert(item != object_map[object_type].end());
ObjTrackState *pNode = item->second;
- assert(obj_data->num_total_objects > 0);
+ assert(num_total_objects > 0);
- obj_data->num_total_objects--;
- assert(obj_data->num_objects[pNode->object_type] > 0);
+ num_total_objects--;
+ assert(num_objects[pNode->object_type] > 0);
- obj_data->num_objects[pNode->object_type]--;
+ num_objects[pNode->object_type]--;
delete pNode;
- obj_data->object_map[object_type].erase(item);
+ object_map[object_type].erase(item);
}
- template <typename T1>
- void DeleteObjectFromMap(T1 object, VulkanObjectType object_type, object_lifetime *obj_data) {
+ template <typename T1, typename T2>
+ void RecordDestroyObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type) {
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);
+ auto item = object_map[object_type].find(object_handle);
+ if (item != object_map[object_type].end()) {
+ DestroyObjectSilently(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) {
+ 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) {
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 = obj_data->object_map[object_type].find(object_handle);
- if (item != obj_data->object_map[object_type].end()) {
+ auto item = object_map[object_type].find(object_handle);
+ if (item != object_map[object_type].end()) {
ObjTrackState *pNode = item->second;
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), obj_data->num_total_objects - 1,
- obj_data->num_objects[pNode->object_type] - 1, object_string[object_type]);
+ object_string[object_type], HandleToUint64(object), num_total_objects - 1,
+ 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) {
@@ -274,23 +256,5 @@
return skip;
}
- template <typename T1, typename T2>
- 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);
- }
-
- 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);
- }
-
#include "object_tracker.h"
};
diff --git a/layers/object_lifetimes.h b/layers/object_lifetimes.h
deleted file mode 100644
index aeb1097..0000000
--- a/layers/object_lifetimes.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/* Copyright (c) 2015-2018 The Khronos Group Inc.
- * Copyright (c) 2015-2018 Valve Corporation
- * Copyright (c) 2015-2018 LunarG, Inc.
- * Copyright (C) 2015-2018 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Mark Lobodzinski <mark@lunarg.com>
- */
-
-#pragma once
-
-#include <vector>
-#include <unordered_map>
-#include "vulkan/vulkan.h"
-#include "vk_object_types.h"
-
-// Object Status -- used to track state of individual objects
-typedef VkFlags ObjectStatusFlags;
-enum ObjectStatusFlagBits {
- OBJSTATUS_NONE = 0x00000000, // No status is set
- OBJSTATUS_FENCE_IS_SUBMITTED = 0x00000001, // Fence has been submitted
- OBJSTATUS_VIEWPORT_BOUND = 0x00000002, // Viewport state object has been bound
- OBJSTATUS_RASTER_BOUND = 0x00000004, // Viewport state object has been bound
- OBJSTATUS_COLOR_BLEND_BOUND = 0x00000008, // Viewport state object has been bound
- OBJSTATUS_DEPTH_STENCIL_BOUND = 0x00000010, // Viewport state object has been bound
- OBJSTATUS_GPU_MEM_MAPPED = 0x00000020, // Memory object is currently mapped
- OBJSTATUS_COMMAND_BUFFER_SECONDARY = 0x00000040, // Command Buffer is of type SECONDARY
- OBJSTATUS_CUSTOM_ALLOCATOR = 0x00000080, // Allocated with custom allocator
-};
-
-// Object and state information structure
-struct ObjTrackState {
- uint64_t handle; // Object handle (new)
- VulkanObjectType object_type; // Object type identifier
- ObjectStatusFlags status; // Object state
- uint64_t parent_object; // Parent object
-};
-
-// Track Queue information
-struct ObjTrackQueueInfo {
- uint32_t queue_node_index;
- VkQueue queue;
-};
-
-typedef std::unordered_map<uint64_t, ObjTrackState *> object_map_type;
-
-struct object_lifetime {
- // Include an object_tracker structure
- uint64_t num_objects[kVulkanObjectTypeMax + 1];
- uint64_t num_total_objects;
- // Vector of unordered_maps per object type to hold ObjTrackState info
- std::vector<object_map_type> object_map;
- // Special-case map for swapchain images
- std::unordered_map<uint64_t, ObjTrackState *> swapchainImageMap;
- // Map of queue information structures, one per queue
- std::unordered_map<VkQueue, ObjTrackQueueInfo *> queue_info_map;
-
- std::vector<VkQueueFamilyProperties> queue_family_properties;
-
- // Default constructor
- object_lifetime() : num_objects{}, num_total_objects(0), object_map{} { object_map.resize(kVulkanObjectTypeMax + 1); }
-};
diff --git a/layers/object_tracker_utils.cpp b/layers/object_tracker_utils.cpp
index 88f367e..a2d2b3c 100644
--- a/layers/object_tracker_utils.cpp
+++ b/layers/object_tracker_utils.cpp
@@ -21,24 +21,24 @@
*/
#include "chassis.h"
+
#include "object_lifetime_validation.h"
uint64_t object_track_index = 0;
// Add new queue to head of global queue list
void ObjectLifetimes::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->objdata.queue_info_map.find(queue);
- if (queueItem == device_data->objdata.queue_info_map.end()) {
+ auto queueItem = queue_info_map.find(queue);
+ if (queueItem == 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->objdata.queue_info_map[queue] = p_queue_info;
+ 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,
+ log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, HandleToUint64(queue),
+ kVUID_ObjectTracker_InternalError,
"ERROR: VK_ERROR_OUT_OF_HOST_MEMORY -- could not allocate memory for Queue Information");
}
}
@@ -46,43 +46,37 @@
// Destroy memRef lists and free all memory
void ObjectLifetimes::DestroyQueueDataStructures(VkDevice device) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
-
- for (auto queue_item : device_data->objdata.queue_info_map) {
+ for (auto queue_item : queue_info_map) {
delete queue_item.second;
}
- device_data->objdata.queue_info_map.clear();
+ queue_info_map.clear();
// Destroy the items in the queue map
- auto queue = device_data->objdata.object_map[kVulkanObjectTypeQueue].begin();
- while (queue != device_data->objdata.object_map[kVulkanObjectTypeQueue].end()) {
+ auto queue = object_map[kVulkanObjectTypeQueue].begin();
+ while (queue != object_map[kVulkanObjectTypeQueue].end()) {
uint32_t obj_index = queue->second->object_type;
- 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,
+ assert(num_total_objects > 0);
+ num_total_objects--;
+ assert(num_objects[obj_index] > 0);
+ num_objects[obj_index]--;
+ log_msg(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->objdata.num_total_objects, device_data->objdata.num_objects[obj_index]);
+ queue->second->handle, num_total_objects, num_objects[obj_index]);
delete queue->second;
- queue = device_data->objdata.object_map[kVulkanObjectTypeQueue].erase(queue);
+ queue = object_map[kVulkanObjectTypeQueue].erase(queue);
}
}
// Check Queue type flags for selected queue operations
void ObjectLifetimes::ValidateQueueFlags(VkQueue queue, const char *function) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
- auto queue_item = device_data->objdata.queue_info_map.find(queue);
- if (queue_item != device_data->objdata.queue_info_map.end()) {
+ auto queue_item = queue_info_map.find(queue);
+ if (queue_item != queue_info_map.end()) {
ObjTrackQueueInfo *pQueueInfo = queue_item->second;
if (pQueueInfo != NULL) {
- 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",
+ if ((queue_family_properties[pQueueInfo->queue_node_index].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) == 0) {
+ log_msg(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);
}
}
@@ -94,25 +88,18 @@
// However, if this layer is loaded first and GetProcAddress is used to make API calls, it will detect bad DOs.
bool ObjectLifetimes::ValidateDeviceObject(uint64_t device_handle, const std::string &invalid_handle_code,
const std::string &wrong_device_code) {
- VkInstance last_instance = nullptr;
- 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 = instance_data.second->instance;
- if (object.second->handle == device_handle) return false;
- }
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ auto instance_object_lifetime_data = GetObjectLifetimeData(instance_data->object_dispatch);
+ for (auto object : instance_object_lifetime_data->object_map[kVulkanObjectTypeDevice]) {
+ if (object.second->handle == device_handle) return false;
}
-
- 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,
+ return log_msg(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);
}
void ObjectLifetimes::AllocateCommandBuffer(VkDevice device, const VkCommandPool command_pool, const VkCommandBuffer command_buffer,
VkCommandBufferLevel level) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
-
- log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+ log_msg(report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
HandleToUint64(command_buffer), kVUID_ObjectTracker_Info, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64,
object_track_index++, "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT", HandleToUint64(command_buffer));
@@ -125,38 +112,34 @@
} else {
pNewObjNode->status = OBJSTATUS_NONE;
}
- device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)] = pNewObjNode;
- device_data->objdata.num_objects[kVulkanObjectTypeCommandBuffer]++;
- device_data->objdata.num_total_objects++;
+ object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)] = pNewObjNode;
+ num_objects[kVulkanObjectTypeCommandBuffer]++;
+ num_total_objects++;
}
bool ObjectLifetimes::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->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 (object_map[kVulkanObjectTypeCommandBuffer].find(object_handle) != object_map[kVulkanObjectTypeCommandBuffer].end()) {
+ ObjTrackState *pNode = 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,
+ skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
object_handle, "VUID-vkFreeCommandBuffers-pCommandBuffers-parent",
"FreeCommandBuffers is attempting to free Command Buffer 0x%" PRIxLEAST64
" belonging to Command Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 ").",
HandleToUint64(command_buffer), pNode->parent_object, HandleToUint64(command_pool));
}
} else {
- skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
- object_handle, "VUID-vkFreeCommandBuffers-pCommandBuffers-00048", "Invalid %s Object 0x%" PRIxLEAST64 ".",
+ skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, object_handle,
+ "VUID-vkFreeCommandBuffers-pCommandBuffers-00048", "Invalid %s Object 0x%" PRIxLEAST64 ".",
object_string[kVulkanObjectTypeCommandBuffer], object_handle);
}
return skip;
}
void ObjectLifetimes::AllocateDescriptorSet(VkDevice device, VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
-
- log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
+ log_msg(report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
HandleToUint64(descriptor_set), kVUID_ObjectTracker_Info, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64,
object_track_index++, "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT", HandleToUint64(descriptor_set));
@@ -165,29 +148,28 @@
pNewObjNode->status = OBJSTATUS_NONE;
pNewObjNode->handle = HandleToUint64(descriptor_set);
pNewObjNode->parent_object = HandleToUint64(descriptor_pool);
- device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet][HandleToUint64(descriptor_set)] = pNewObjNode;
- device_data->objdata.num_objects[kVulkanObjectTypeDescriptorSet]++;
- device_data->objdata.num_total_objects++;
+ object_map[kVulkanObjectTypeDescriptorSet][HandleToUint64(descriptor_set)] = pNewObjNode;
+ num_objects[kVulkanObjectTypeDescriptorSet]++;
+ num_total_objects++;
}
bool ObjectLifetimes::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->objdata.object_map[kVulkanObjectTypeDescriptorSet].find(object_handle);
- if (dsItem != device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet].end()) {
+ auto dsItem = object_map[kVulkanObjectTypeDescriptorSet].find(object_handle);
+ if (dsItem != object_map[kVulkanObjectTypeDescriptorSet].end()) {
ObjTrackState *pNode = dsItem->second;
if (pNode->parent_object != HandleToUint64(descriptor_pool)) {
- skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
+ skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
object_handle, "VUID-vkFreeDescriptorSets-pDescriptorSets-parent",
"FreeDescriptorSets is attempting to free descriptorSet 0x%" PRIxLEAST64
" belonging to Descriptor Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 ").",
HandleToUint64(descriptor_set), pNode->parent_object, HandleToUint64(descriptor_pool));
}
} else {
- skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
- object_handle, "VUID-vkFreeDescriptorSets-pDescriptorSets-00310", "Invalid %s Object 0x%" PRIxLEAST64 ".",
+ skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, object_handle,
+ "VUID-vkFreeDescriptorSets-pDescriptorSets-00310", "Invalid %s Object 0x%" PRIxLEAST64 ".",
object_string[kVulkanObjectTypeDescriptorSet], object_handle);
}
return skip;
@@ -198,16 +180,15 @@
bool skip = false;
if (!isPush && desc->dstSet) {
- skip |= DeviceValidateObject(disp, desc->dstSet, kVulkanObjectTypeDescriptorSet, false,
- "VUID-VkWriteDescriptorSet-dstSet-00320", "VUID-VkWriteDescriptorSet-commonparent");
+ skip |= ValidateObject(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 |=
- DeviceValidateObject(disp, desc->pTexelBufferView[idx2], kVulkanObjectTypeBufferView, false,
- "VUID-VkWriteDescriptorSet-descriptorType-00323", "VUID-VkWriteDescriptorSet-commonparent");
+ skip |= ValidateObject(disp, desc->pTexelBufferView[idx2], kVulkanObjectTypeBufferView, false,
+ "VUID-VkWriteDescriptorSet-descriptorType-00323", "VUID-VkWriteDescriptorSet-commonparent");
}
}
@@ -215,9 +196,8 @@
(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 |=
- DeviceValidateObject(disp, desc->pImageInfo[idx3].imageView, kVulkanObjectTypeImageView, false,
- "VUID-VkWriteDescriptorSet-descriptorType-00326", "VUID-VkDescriptorImageInfo-commonparent");
+ skip |= ValidateObject(disp, desc->pImageInfo[idx3].imageView, kVulkanObjectTypeImageView, false,
+ "VUID-VkWriteDescriptorSet-descriptorType-00326", "VUID-VkDescriptorImageInfo-commonparent");
}
}
@@ -227,8 +207,8 @@
(desc->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) {
for (uint32_t idx4 = 0; idx4 < desc->descriptorCount; ++idx4) {
if (desc->pBufferInfo[idx4].buffer) {
- skip |= DeviceValidateObject(disp, desc->pBufferInfo[idx4].buffer, kVulkanObjectTypeBuffer, false,
- "VUID-VkDescriptorBufferInfo-buffer-parameter", kVUIDUndefined);
+ skip |= ValidateObject(disp, desc->pBufferInfo[idx4].buffer, kVulkanObjectTypeBuffer, false,
+ "VUID-VkDescriptorBufferInfo-buffer-parameter", kVUIDUndefined);
}
}
}
@@ -240,11 +220,10 @@
VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount,
const VkWriteDescriptorSet *pDescriptorWrites) {
bool skip = false;
- 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");
+ 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");
if (pDescriptorWrites) {
for (uint32_t index0 = 0; index0 < descriptorWriteCount; ++index0) {
skip |= ValidateDescriptorWrite(commandBuffer, &pDescriptorWrites[index0], true);
@@ -254,19 +233,17 @@
}
void ObjectLifetimes::CreateQueue(VkDevice device, VkQueue vkObj) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
-
- log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
- HandleToUint64(vkObj), kVUID_ObjectTracker_Info, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64,
- object_track_index++, "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT", HandleToUint64(vkObj));
+ log_msg(report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, HandleToUint64(vkObj),
+ kVUID_ObjectTracker_Info, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++,
+ "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT", HandleToUint64(vkObj));
ObjTrackState *p_obj_node = NULL;
- auto queue_item = device_data->objdata.object_map[kVulkanObjectTypeQueue].find(HandleToUint64(vkObj));
- if (queue_item == device_data->objdata.object_map[kVulkanObjectTypeQueue].end()) {
+ auto queue_item = object_map[kVulkanObjectTypeQueue].find(HandleToUint64(vkObj));
+ if (queue_item == object_map[kVulkanObjectTypeQueue].end()) {
p_obj_node = new ObjTrackState;
- device_data->objdata.object_map[kVulkanObjectTypeQueue][HandleToUint64(vkObj)] = p_obj_node;
- device_data->objdata.num_objects[kVulkanObjectTypeQueue]++;
- device_data->objdata.num_total_objects++;
+ object_map[kVulkanObjectTypeQueue][HandleToUint64(vkObj)] = p_obj_node;
+ num_objects[kVulkanObjectTypeQueue]++;
+ num_total_objects++;
} else {
p_obj_node = queue_item->second;
}
@@ -276,8 +253,7 @@
}
void ObjectLifetimes::CreateSwapchainImageObject(VkDevice dispatchable_object, VkImage swapchain_image, VkSwapchainKHR swapchain) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
- log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+ log_msg(report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
HandleToUint64(swapchain_image), kVUID_ObjectTracker_Info, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64,
object_track_index++, "SwapchainImage", HandleToUint64(swapchain_image));
@@ -286,69 +262,65 @@
pNewObjNode->status = OBJSTATUS_NONE;
pNewObjNode->handle = HandleToUint64(swapchain_image);
pNewObjNode->parent_object = HandleToUint64(swapchain);
- device_data->objdata.swapchainImageMap[HandleToUint64(swapchain_image)] = pNewObjNode;
+ swapchainImageMap[HandleToUint64(swapchain_image)] = pNewObjNode;
}
bool ObjectLifetimes::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->objdata.object_map[object_type]) {
+ for (const auto &item : 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,
- "OBJ ERROR : For device 0x%" PRIxLEAST64 ", %s object 0x%" PRIxLEAST64 " has not been destroyed.",
- HandleToUint64(device), object_string[object_type], object_info->handle);
+ skip |=
+ log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, get_debug_report_enum[object_type], object_info->handle, error_code,
+ "OBJ ERROR : For device 0x%" PRIxLEAST64 ", %s object 0x%" PRIxLEAST64 " has not been destroyed.",
+ HandleToUint64(device), object_string[object_type], object_info->handle);
}
return skip;
}
void ObjectLifetimes::DeviceDestroyUndestroyedObjects(VkDevice device, VulkanObjectType object_type) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- while (!device_data->objdata.object_map[object_type].empty()) {
- auto item = device_data->objdata.object_map[object_type].begin();
+ while (!object_map[object_type].empty()) {
+ auto item = object_map[object_type].begin();
ObjTrackState *object_info = item->second;
- DestroyObjectSilently(&device_data->objdata, object_info->handle, object_type);
+ DestroyObjectSilently(object_info->handle, object_type);
}
}
bool ObjectLifetimes::PreCallValidateDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
- dispatch_key key = get_dispatch_key(instance);
- 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 |= InstanceValidateObject(instance, instance, kVulkanObjectTypeInstance, true, "VUID-vkDestroyInstance-instance-parameter",
- kVUIDUndefined);
+ skip |= ValidateObject(instance, instance, kVulkanObjectTypeInstance, true, "VUID-vkDestroyInstance-instance-parameter",
+ kVUIDUndefined);
// Validate that child devices have been destroyed
- for (const auto &iit : instance_data->objdata.object_map[kVulkanObjectTypeDevice]) {
+ for (const auto &iit : object_map[kVulkanObjectTypeDevice]) {
ObjTrackState *pNode = iit.second;
VkDevice device = reinterpret_cast<VkDevice>(pNode->handle);
VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[pNode->object_type];
- skip |= log_msg(instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, pNode->handle,
+ skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, pNode->handle,
kVUID_ObjectTracker_ObjectLeak, "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.",
string_VkDebugReportObjectTypeEXT(debug_object_type), pNode->handle);
// Report any remaining objects in LL
skip |= ReportUndestroyedObjects(device, "VUID-vkDestroyInstance-instance-00629");
- skip |= InstanceValidateDestroyObject(instance, device, kVulkanObjectTypeDevice, pAllocator,
- "VUID-vkDestroyInstance-instance-00630", "VUID-vkDestroyInstance-instance-00631");
+ skip |= ValidateDestroyObject(instance, device, kVulkanObjectTypeDevice, pAllocator,
+ "VUID-vkDestroyInstance-instance-00630", "VUID-vkDestroyInstance-instance-00631");
}
- InstanceValidateDestroyObject(instance, instance, kVulkanObjectTypeInstance, pAllocator,
- "VUID-vkDestroyInstance-instance-00630", "VUID-vkDestroyInstance-instance-00631");
+ ValidateDestroyObject(instance, instance, kVulkanObjectTypeInstance, pAllocator, "VUID-vkDestroyInstance-instance-00630",
+ "VUID-vkDestroyInstance-instance-00631");
return skip;
}
bool ObjectLifetimes::PreCallValidateEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
VkPhysicalDevice *pPhysicalDevices) {
- bool skip = InstanceValidateObject(instance, instance, kVulkanObjectTypeInstance, false,
- "VUID-vkEnumeratePhysicalDevices-instance-parameter", kVUIDUndefined);
+ bool skip = ValidateObject(instance, instance, kVulkanObjectTypeInstance, false,
+ "VUID-vkEnumeratePhysicalDevices-instance-parameter", kVUIDUndefined);
return skip;
}
@@ -356,49 +328,43 @@
VkPhysicalDevice *pPhysicalDevices) {
if (pPhysicalDevices) {
for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) {
- InstanceCreateObject(instance, pPhysicalDevices[i], kVulkanObjectTypePhysicalDevice, nullptr);
+ CreateObject(instance, pPhysicalDevices[i], kVulkanObjectTypePhysicalDevice, nullptr);
}
}
}
void ObjectLifetimes::PreCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
- dispatch_key key = get_dispatch_key(instance);
- instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map);
-
// Destroy physical devices
- for (auto iit = instance_data->objdata.object_map[kVulkanObjectTypePhysicalDevice].begin();
- iit != instance_data->objdata.object_map[kVulkanObjectTypePhysicalDevice].end();) {
+ for (auto iit = object_map[kVulkanObjectTypePhysicalDevice].begin();
+ iit != object_map[kVulkanObjectTypePhysicalDevice].end();) {
ObjTrackState *pNode = iit->second;
VkPhysicalDevice physical_device = reinterpret_cast<VkPhysicalDevice>(pNode->handle);
- InstanceRecordDestroyObject(instance, physical_device, kVulkanObjectTypePhysicalDevice);
- iit = instance_data->objdata.object_map[kVulkanObjectTypePhysicalDevice].begin();
+ RecordDestroyObject(instance, physical_device, kVulkanObjectTypePhysicalDevice);
+ iit = object_map[kVulkanObjectTypePhysicalDevice].begin();
}
// Destroy child devices
- for (auto iit = instance_data->objdata.object_map[kVulkanObjectTypeDevice].begin();
- iit != instance_data->objdata.object_map[kVulkanObjectTypeDevice].end();) {
+ for (auto iit = object_map[kVulkanObjectTypeDevice].begin(); iit != object_map[kVulkanObjectTypeDevice].end();) {
ObjTrackState *pNode = iit->second;
VkDevice device = reinterpret_cast<VkDevice>(pNode->handle);
DestroyUndestroyedObjects(device);
- InstanceRecordDestroyObject(instance, device, kVulkanObjectTypeDevice);
- iit = instance_data->objdata.object_map[kVulkanObjectTypeDevice].begin();
+ RecordDestroyObject(instance, device, kVulkanObjectTypeDevice);
+ iit = object_map[kVulkanObjectTypeDevice].begin();
}
- instance_data->objdata.object_map[kVulkanObjectTypeDevice].clear();
+ object_map[kVulkanObjectTypeDevice].clear();
}
void ObjectLifetimes::PostCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
- InstanceRecordDestroyObject(instance, instance, kVulkanObjectTypeInstance);
+ RecordDestroyObject(instance, instance, kVulkanObjectTypeInstance);
}
bool ObjectLifetimes::PreCallValidateDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
- 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");
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, true, "VUID-vkDestroyDevice-device-parameter", kVUIDUndefined);
+ skip |= ValidateDestroyObject(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");
@@ -406,8 +372,7 @@
}
void ObjectLifetimes::PreCallRecordDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- InstanceRecordDestroyObject(device_data->physical_device, device, kVulkanObjectTypeDevice);
+ RecordDestroyObject(physical_device, device, kVulkanObjectTypeDevice);
DestroyUndestroyedObjects(device);
// Clean up Queue's MemRef Linked Lists
@@ -417,8 +382,8 @@
bool ObjectLifetimes::PreCallValidateGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
VkQueue *pQueue) {
bool skip = false;
- skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceQueue-device-parameter",
- kVUIDUndefined);
+ skip |=
+ ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceQueue-device-parameter", kVUIDUndefined);
return skip;
}
@@ -429,8 +394,8 @@
}
bool ObjectLifetimes::PreCallValidateGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) {
- return DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceQueue2-device-parameter",
- kVUIDUndefined);
+ return ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetDeviceQueue2-device-parameter",
+ kVUIDUndefined);
}
void ObjectLifetimes::PostCallRecordGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) {
@@ -443,17 +408,17 @@
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet *pDescriptorCopies) {
bool skip = false;
- skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkUpdateDescriptorSets-device-parameter",
- kVUIDUndefined);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkUpdateDescriptorSets-device-parameter",
+ kVUIDUndefined);
if (pDescriptorCopies) {
for (uint32_t idx0 = 0; idx0 < descriptorCopyCount; ++idx0) {
if (pDescriptorCopies[idx0].dstSet) {
- skip |= DeviceValidateObject(device, pDescriptorCopies[idx0].dstSet, kVulkanObjectTypeDescriptorSet, false,
- "VUID-VkCopyDescriptorSet-dstSet-parameter", "VUID-VkCopyDescriptorSet-commonparent");
+ skip |= ValidateObject(device, pDescriptorCopies[idx0].dstSet, kVulkanObjectTypeDescriptorSet, false,
+ "VUID-VkCopyDescriptorSet-dstSet-parameter", "VUID-VkCopyDescriptorSet-commonparent");
}
if (pDescriptorCopies[idx0].srcSet) {
- skip |= DeviceValidateObject(device, pDescriptorCopies[idx0].srcSet, kVulkanObjectTypeDescriptorSet, false,
- "VUID-VkCopyDescriptorSet-srcSet-parameter", "VUID-VkCopyDescriptorSet-commonparent");
+ skip |= ValidateObject(device, pDescriptorCopies[idx0].srcSet, kVulkanObjectTypeDescriptorSet, false,
+ "VUID-VkCopyDescriptorSet-srcSet-parameter", "VUID-VkCopyDescriptorSet-commonparent");
}
}
}
@@ -468,17 +433,16 @@
bool ObjectLifetimes::PreCallValidateResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags) {
bool skip = false;
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- 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]) {
+ 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 : object_map[kVulkanObjectTypeDescriptorSet]) {
if (itr.second->parent_object == HandleToUint64(descriptorPool)) {
- skip |= DeviceValidateDestroyObject(device, (VkDescriptorSet)(itr.first), kVulkanObjectTypeDescriptorSet, nullptr,
- kVUIDUndefined, kVUIDUndefined);
+ skip |= ValidateDestroyObject(device, (VkDescriptorSet)(itr.first), kVulkanObjectTypeDescriptorSet, nullptr,
+ kVUIDUndefined, kVUIDUndefined);
}
}
return skip;
@@ -486,36 +450,31 @@
void ObjectLifetimes::PreCallRecordResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
-
// 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->objdata.object_map[kVulkanObjectTypeDescriptorSet].begin();
- while (itr != device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet].end()) {
+ auto itr = object_map[kVulkanObjectTypeDescriptorSet].begin();
+ while (itr != object_map[kVulkanObjectTypeDescriptorSet].end()) {
ObjTrackState *pNode = (*itr).second;
auto del_itr = itr++;
if (pNode->parent_object == HandleToUint64(descriptorPool)) {
- DeviceRecordDestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet);
+ RecordDestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet);
}
}
}
bool ObjectLifetimes::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 |= DeviceValidateObject(command_buffer, command_buffer, kVulkanObjectTypeCommandBuffer, false,
- "VUID-vkBeginCommandBuffer-commandBuffer-parameter", kVUIDUndefined);
+ skip |= ValidateObject(command_buffer, command_buffer, kVulkanObjectTypeCommandBuffer, false,
+ "VUID-vkBeginCommandBuffer-commandBuffer-parameter", kVUIDUndefined);
if (begin_info) {
- ObjTrackState *pNode = device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)];
+ ObjTrackState *pNode = 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 |= 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");
+ 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");
}
}
return skip;
@@ -524,10 +483,10 @@
bool ObjectLifetimes::PreCallValidateGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) {
bool skip = false;
- 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");
+ 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");
return skip;
}
@@ -544,8 +503,8 @@
const VkAllocationCallbacks *pAllocator,
VkDescriptorSetLayout *pSetLayout) {
bool skip = false;
- skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false,
- "VUID-vkCreateDescriptorSetLayout-device-parameter", kVUIDUndefined);
+ skip |= ValidateObject(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) {
@@ -555,8 +514,8 @@
if (binding.pImmutableSamplers && is_sampler_type) {
for (uint32_t index2 = 0; index2 < binding.descriptorCount; ++index2) {
const VkSampler sampler = binding.pImmutableSamplers[index2];
- skip |= DeviceValidateObject(device, sampler, kVulkanObjectTypeSampler, false,
- "VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", kVUIDUndefined);
+ skip |= ValidateObject(device, sampler, kVulkanObjectTypeSampler, false,
+ "VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", kVUIDUndefined);
}
}
}
@@ -568,7 +527,7 @@
void ObjectLifetimes::PostCallRecordCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDescriptorSetLayout *pSetLayout) {
- DeviceCreateObject(device, *pSetLayout, kVulkanObjectTypeDescriptorSetLayout, pAllocator);
+ CreateObject(device, *pSetLayout, kVulkanObjectTypeDescriptorSetLayout, pAllocator);
}
bool ObjectLifetimes::ValidateSamplerObjects(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo) {
@@ -577,9 +536,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 |= DeviceValidateObject(device, pCreateInfo->pBindings[index1].pImmutableSamplers[index2],
- kVulkanObjectTypeSampler, true,
- "VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", kVUIDUndefined);
+ skip |=
+ ValidateObject(device, pCreateInfo->pBindings[index1].pImmutableSamplers[index2], kVulkanObjectTypeSampler,
+ true, "VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", kVUIDUndefined);
}
}
}
@@ -590,8 +549,8 @@
bool ObjectLifetimes::PreCallValidateGetDescriptorSetLayoutSupport(VkDevice device,
const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
VkDescriptorSetLayoutSupport *pSupport) {
- bool skip = DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false,
- "VUID-vkGetDescriptorSetLayoutSupport-device-parameter", kVUIDUndefined);
+ bool skip = ValidateObject(device, device, kVulkanObjectTypeDevice, false,
+ "VUID-vkGetDescriptorSetLayoutSupport-device-parameter", kVUIDUndefined);
if (pCreateInfo) {
skip |= ValidateSamplerObjects(device, pCreateInfo);
}
@@ -600,8 +559,8 @@
bool ObjectLifetimes::PreCallValidateGetDescriptorSetLayoutSupportKHR(VkDevice device,
const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
VkDescriptorSetLayoutSupport *pSupport) {
- bool skip = DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false,
- "VUID-vkGetDescriptorSetLayoutSupportKHR-device-parameter", kVUIDUndefined);
+ bool skip = ValidateObject(device, device, kVulkanObjectTypeDevice, false,
+ "VUID-vkGetDescriptorSetLayoutSupportKHR-device-parameter", kVUIDUndefined);
if (pCreateInfo) {
skip |= ValidateSamplerObjects(device, pCreateInfo);
}
@@ -611,36 +570,35 @@
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties *pQueueFamilyProperties) {
- return InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter", kVUIDUndefined);
+ return ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetPhysicalDeviceQueueFamilyProperties-physicalDevice-parameter", kVUIDUndefined);
}
void ObjectLifetimes::PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties *pQueueFamilyProperties) {
if (pQueueFamilyProperties != NULL) {
- 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);
+ if (queue_family_properties.size() < *pQueueFamilyPropertyCount) {
+ queue_family_properties.resize(*pQueueFamilyPropertyCount);
}
for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) {
- instance_data->objdata.queue_family_properties[i] = pQueueFamilyProperties[i];
+ queue_family_properties[i] = pQueueFamilyProperties[i];
}
}
}
void ObjectLifetimes::PostCallRecordCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
VkInstance *pInstance) {
- InstanceCreateObject(*pInstance, *pInstance, kVulkanObjectTypeInstance, pAllocator);
+ CreateObject(*pInstance, *pInstance, kVulkanObjectTypeInstance, pAllocator);
}
bool ObjectLifetimes::PreCallValidateAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo,
VkCommandBuffer *pCommandBuffers) {
bool skip = false;
- skip |= DeviceValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkAllocateCommandBuffers-device-parameter",
- kVUIDUndefined);
- skip |= DeviceValidateObject(device, pAllocateInfo->commandPool, kVulkanObjectTypeCommandPool, false,
- "VUID-VkCommandBufferAllocateInfo-commandPool-parameter", kVUIDUndefined);
+ skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkAllocateCommandBuffers-device-parameter",
+ kVUIDUndefined);
+ skip |= ValidateObject(device, pAllocateInfo->commandPool, kVulkanObjectTypeCommandPool, false,
+ "VUID-VkCommandBufferAllocateInfo-commandPool-parameter", kVUIDUndefined);
return skip;
}
@@ -654,15 +612,15 @@
bool ObjectLifetimes::PreCallValidateAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo,
VkDescriptorSet *pDescriptorSets) {
bool skip = false;
- 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");
+ 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");
for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
- skip |= DeviceValidateObject(device, pAllocateInfo->pSetLayouts[i], kVulkanObjectTypeDescriptorSetLayout, false,
- "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter",
- "VUID-VkDescriptorSetAllocateInfo-commonparent");
+ skip |= ValidateObject(device, pAllocateInfo->pSetLayouts[i], kVulkanObjectTypeDescriptorSetLayout, false,
+ "VUID-VkDescriptorSetAllocateInfo-pSetLayouts-parameter",
+ "VUID-VkDescriptorSetAllocateInfo-commonparent");
}
return skip;
}
@@ -677,15 +635,15 @@
bool ObjectLifetimes::PreCallValidateFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
const VkCommandBuffer *pCommandBuffers) {
bool skip = false;
- 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");
+ 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");
for (uint32_t i = 0; i < commandBufferCount; i++) {
if (pCommandBuffers[i] != VK_NULL_HANDLE) {
skip |= ValidateCommandBuffer(device, commandPool, pCommandBuffers[i]);
- skip |= DeviceValidateDestroyObject(device, pCommandBuffers[i], kVulkanObjectTypeCommandBuffer, nullptr, kVUIDUndefined,
- kVUIDUndefined);
+ skip |= ValidateDestroyObject(device, pCommandBuffers[i], kVulkanObjectTypeCommandBuffer, nullptr, kVUIDUndefined,
+ kVUIDUndefined);
}
}
return skip;
@@ -694,27 +652,26 @@
void ObjectLifetimes::PreCallRecordFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
const VkCommandBuffer *pCommandBuffers) {
for (uint32_t i = 0; i < commandBufferCount; i++) {
- DeviceRecordDestroyObject(device, pCommandBuffers[i], kVulkanObjectTypeCommandBuffer);
+ RecordDestroyObject(device, pCommandBuffers[i], kVulkanObjectTypeCommandBuffer);
}
}
bool ObjectLifetimes::PreCallValidateDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
const VkAllocationCallbacks *pAllocator) {
- return DeviceValidateDestroyObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, pAllocator,
- "VUID-vkDestroySwapchainKHR-swapchain-01283", "VUID-vkDestroySwapchainKHR-swapchain-01284");
+ return ValidateDestroyObject(device, swapchain, kVulkanObjectTypeSwapchainKHR, pAllocator,
+ "VUID-vkDestroySwapchainKHR-swapchain-01283", "VUID-vkDestroySwapchainKHR-swapchain-01284");
}
void ObjectLifetimes::PreCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
const VkAllocationCallbacks *pAllocator) {
- 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->objdata.swapchainImageMap.begin();
- while (itr != device_data->objdata.swapchainImageMap.end()) {
+ RecordDestroyObject(device, swapchain, kVulkanObjectTypeSwapchainKHR);
+ std::unordered_map<uint64_t, ObjTrackState *>::iterator itr = swapchainImageMap.begin();
+ while (itr != swapchainImageMap.end()) {
ObjTrackState *pNode = (*itr).second;
if (pNode->parent_object == HandleToUint64(swapchain)) {
delete pNode;
auto delete_item = itr++;
- device_data->objdata.swapchainImageMap.erase(delete_item);
+ swapchainImageMap.erase(delete_item);
} else {
++itr;
}
@@ -724,16 +681,15 @@
bool ObjectLifetimes::PreCallValidateFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets) {
bool skip = false;
- 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");
+ 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");
for (uint32_t i = 0; i < descriptorSetCount; i++) {
if (pDescriptorSets[i] != VK_NULL_HANDLE) {
skip |= ValidateDescriptorSet(device, descriptorPool, pDescriptorSets[i]);
- skip |= DeviceValidateDestroyObject(device, pDescriptorSets[i], kVulkanObjectTypeDescriptorSet, nullptr, kVUIDUndefined,
- kVUIDUndefined);
+ skip |= ValidateDestroyObject(device, pDescriptorSets[i], kVulkanObjectTypeDescriptorSet, nullptr, kVUIDUndefined,
+ kVUIDUndefined);
}
}
return skip;
@@ -741,127 +697,118 @@
void ObjectLifetimes::PreCallRecordFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount,
const VkDescriptorSet *pDescriptorSets) {
for (uint32_t i = 0; i < descriptorSetCount; i++) {
- DeviceRecordDestroyObject(device, pDescriptorSets[i], kVulkanObjectTypeDescriptorSet);
+ RecordDestroyObject(device, pDescriptorSets[i], kVulkanObjectTypeDescriptorSet);
}
}
bool ObjectLifetimes::PreCallValidateDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
const VkAllocationCallbacks *pAllocator) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
- 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()) {
+ 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 = object_map[kVulkanObjectTypeDescriptorSet].begin();
+ while (itr != object_map[kVulkanObjectTypeDescriptorSet].end()) {
ObjTrackState *pNode = (*itr).second;
auto del_itr = itr++;
if (pNode->parent_object == HandleToUint64(descriptorPool)) {
- skip |= DeviceValidateDestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet,
- nullptr, kVUIDUndefined, kVUIDUndefined);
+ skip |= ValidateDestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet, nullptr,
+ kVUIDUndefined, kVUIDUndefined);
}
}
- skip |= DeviceValidateDestroyObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, pAllocator,
- "VUID-vkDestroyDescriptorPool-descriptorPool-00304",
- "VUID-vkDestroyDescriptorPool-descriptorPool-00305");
+ skip |= ValidateDestroyObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool, pAllocator,
+ "VUID-vkDestroyDescriptorPool-descriptorPool-00304",
+ "VUID-vkDestroyDescriptorPool-descriptorPool-00305");
return skip;
}
void ObjectLifetimes::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->objdata.object_map[kVulkanObjectTypeDescriptorSet].begin();
- while (itr != device_data->objdata.object_map[kVulkanObjectTypeDescriptorSet].end()) {
+ std::unordered_map<uint64_t, ObjTrackState *>::iterator itr = object_map[kVulkanObjectTypeDescriptorSet].begin();
+ while (itr != object_map[kVulkanObjectTypeDescriptorSet].end()) {
ObjTrackState *pNode = (*itr).second;
auto del_itr = itr++;
if (pNode->parent_object == HandleToUint64(descriptorPool)) {
- DeviceRecordDestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet);
+ RecordDestroyObject(device, (VkDescriptorSet)((*del_itr).first), kVulkanObjectTypeDescriptorSet);
}
}
- DeviceRecordDestroyObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool);
+ RecordDestroyObject(device, descriptorPool, kVulkanObjectTypeDescriptorPool);
}
bool ObjectLifetimes::PreCallValidateDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
const VkAllocationCallbacks *pAllocator) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
- 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();
+ 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 = object_map[kVulkanObjectTypeCommandBuffer].begin();
auto del_itr = itr;
- while (itr != device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer].end()) {
+ while (itr != 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 |= DeviceValidateDestroyObject(device, reinterpret_cast<VkCommandBuffer>((*del_itr).first),
- kVulkanObjectTypeCommandBuffer, nullptr, kVUIDUndefined, kVUIDUndefined);
+ skip |= ValidateDestroyObject(device, reinterpret_cast<VkCommandBuffer>((*del_itr).first),
+ kVulkanObjectTypeCommandBuffer, nullptr, kVUIDUndefined, kVUIDUndefined);
}
}
- skip |=
- DeviceValidateDestroyObject(device, commandPool, kVulkanObjectTypeCommandPool, pAllocator,
- "VUID-vkDestroyCommandPool-commandPool-00042", "VUID-vkDestroyCommandPool-commandPool-00043");
+ skip |= ValidateDestroyObject(device, commandPool, kVulkanObjectTypeCommandPool, pAllocator,
+ "VUID-vkDestroyCommandPool-commandPool-00042", "VUID-vkDestroyCommandPool-commandPool-00043");
return skip;
}
void ObjectLifetimes::PreCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
const VkAllocationCallbacks *pAllocator) {
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
- auto itr = device_data->objdata.object_map[kVulkanObjectTypeCommandBuffer].begin();
+ auto itr = 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->objdata.object_map[kVulkanObjectTypeCommandBuffer].end()) {
+ while (itr != object_map[kVulkanObjectTypeCommandBuffer].end()) {
ObjTrackState *pNode = (*itr).second;
del_itr = itr++;
if (pNode->parent_object == HandleToUint64(commandPool)) {
- DeviceRecordDestroyObject(device, reinterpret_cast<VkCommandBuffer>((*del_itr).first), kVulkanObjectTypeCommandBuffer);
+ RecordDestroyObject(device, reinterpret_cast<VkCommandBuffer>((*del_itr).first), kVulkanObjectTypeCommandBuffer);
}
}
- DeviceRecordDestroyObject(device, commandPool, kVulkanObjectTypeCommandPool);
+ RecordDestroyObject(device, commandPool, kVulkanObjectTypeCommandPool);
}
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
- return InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter", kVUIDUndefined);
+ return ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetPhysicalDeviceQueueFamilyProperties2-physicalDevice-parameter", kVUIDUndefined);
}
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties2 *pQueueFamilyProperties) {
- return InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetPhysicalDeviceQueueFamilyProperties2KHR-physicalDevice-parameter", kVUIDUndefined);
+ return ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetPhysicalDeviceQueueFamilyProperties2KHR-physicalDevice-parameter", kVUIDUndefined);
}
void ObjectLifetimes::PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
- instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
if (pQueueFamilyProperties != NULL) {
- if (instance_data->objdata.queue_family_properties.size() < *pQueueFamilyPropertyCount) {
- instance_data->objdata.queue_family_properties.resize(*pQueueFamilyPropertyCount);
+ if (queue_family_properties.size() < *pQueueFamilyPropertyCount) {
+ queue_family_properties.resize(*pQueueFamilyPropertyCount);
}
for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) {
- instance_data->objdata.queue_family_properties[i] = pQueueFamilyProperties[i].queueFamilyProperties;
+ queue_family_properties[i] = pQueueFamilyProperties[i].queueFamilyProperties;
}
}
}
void ObjectLifetimes::PostCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(
VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
- instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
if (pQueueFamilyProperties != NULL) {
- if (instance_data->objdata.queue_family_properties.size() < *pQueueFamilyPropertyCount) {
- instance_data->objdata.queue_family_properties.resize(*pQueueFamilyPropertyCount);
+ if (queue_family_properties.size() < *pQueueFamilyPropertyCount) {
+ queue_family_properties.resize(*pQueueFamilyPropertyCount);
}
for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) {
- instance_data->objdata.queue_family_properties[i] = pQueueFamilyProperties[i].queueFamilyProperties;
+ queue_family_properties[i] = pQueueFamilyProperties[i].queueFamilyProperties;
}
}
}
@@ -869,15 +816,15 @@
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
uint32_t *pPropertyCount,
VkDisplayPropertiesKHR *pProperties) {
- return InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter", kVUIDUndefined);
+ return ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetPhysicalDeviceDisplayPropertiesKHR-physicalDevice-parameter", kVUIDUndefined);
}
void ObjectLifetimes::PostCallRecordGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
VkDisplayPropertiesKHR *pProperties) {
if (pProperties) {
for (uint32_t i = 0; i < *pPropertyCount; ++i) {
- InstanceCreateObject(physicalDevice, pProperties[i].display, kVulkanObjectTypeDisplayKHR, nullptr);
+ CreateObject(physicalDevice, pProperties[i].display, kVulkanObjectTypeDisplayKHR, nullptr);
}
}
}
@@ -886,10 +833,10 @@
uint32_t *pPropertyCount,
VkDisplayModePropertiesKHR *pProperties) {
bool skip = false;
- skip |= InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter", kVUIDUndefined);
- skip |= InstanceValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false,
- "VUID-vkGetDisplayModePropertiesKHR-display-parameter", kVUIDUndefined);
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetDisplayModePropertiesKHR-physicalDevice-parameter", kVUIDUndefined);
+ skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false,
+ "VUID-vkGetDisplayModePropertiesKHR-display-parameter", kVUIDUndefined);
return skip;
}
@@ -898,7 +845,7 @@
uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) {
if (pProperties) {
for (uint32_t i = 0; i < *pPropertyCount; ++i) {
- InstanceCreateObject(physicalDevice, pProperties[i].displayMode, kVulkanObjectTypeDisplayModeKHR, nullptr);
+ CreateObject(physicalDevice, pProperties[i].displayMode, kVulkanObjectTypeDisplayModeKHR, nullptr);
}
}
}
@@ -906,15 +853,15 @@
bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
uint32_t *pPropertyCount,
VkDisplayProperties2KHR *pProperties) {
- return InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-physicalDevice-parameter", kVUIDUndefined);
+ return ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetPhysicalDeviceDisplayProperties2KHR-physicalDevice-parameter", kVUIDUndefined);
}
void ObjectLifetimes::PostCallRecordGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
uint32_t *pPropertyCount,
VkDisplayProperties2KHR *pProperties) {
for (uint32_t index = 0; index < *pPropertyCount; ++index) {
- InstanceCreateObject(physicalDevice, pProperties[index].displayProperties.display, kVulkanObjectTypeDisplayKHR, nullptr);
+ CreateObject(physicalDevice, pProperties[index].displayProperties.display, kVulkanObjectTypeDisplayKHR, nullptr);
}
}
@@ -922,10 +869,10 @@
uint32_t *pPropertyCount,
VkDisplayModeProperties2KHR *pProperties) {
bool skip = false;
- skip |= InstanceValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
- "VUID-vkGetDisplayModeProperties2KHR-physicalDevice-parameter", kVUIDUndefined);
- skip |= InstanceValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false,
- "VUID-vkGetDisplayModeProperties2KHR-display-parameter", kVUIDUndefined);
+ skip |= ValidateObject(physicalDevice, physicalDevice, kVulkanObjectTypePhysicalDevice, false,
+ "VUID-vkGetDisplayModeProperties2KHR-physicalDevice-parameter", kVUIDUndefined);
+ skip |= ValidateObject(physicalDevice, display, kVulkanObjectTypeDisplayKHR, false,
+ "VUID-vkGetDisplayModeProperties2KHR-display-parameter", kVUIDUndefined);
return skip;
}
@@ -934,7 +881,7 @@
uint32_t *pPropertyCount,
VkDisplayModeProperties2KHR *pProperties) {
for (uint32_t index = 0; index < *pPropertyCount; ++index) {
- InstanceCreateObject(physicalDevice, pProperties[index].displayModeProperties.displayMode, kVulkanObjectTypeDisplayModeKHR,
- nullptr);
+ CreateObject(physicalDevice, pProperties[index].displayModeProperties.displayMode, kVulkanObjectTypeDisplayModeKHR,
+ nullptr);
}
}
diff --git a/scripts/layer_chassis_generator.py b/scripts/layer_chassis_generator.py
index 9234bc6..de4d98d 100644
--- a/scripts/layer_chassis_generator.py
+++ b/scripts/layer_chassis_generator.py
@@ -123,7 +123,9 @@
'group', 'bitmask', 'funcpointer', 'struct']
ALL_SECTIONS = TYPE_SECTIONS + ['command']
-
+ precallvalidate_loop = "for (auto intercept : layer_data->object_dispatch) {"
+ precallrecord_loop = precallvalidate_loop
+ postcallrecord_loop = "for (auto intercept : layer_data->object_dispatch) {"
inline_custom_source_preamble = """
@@ -157,17 +159,10 @@
#include "chassis.h"
-class layer_chassis;
+std::unordered_map<void*, ValidationObject*> layer_data_map;
-std::vector<layer_chassis *> global_interceptor_list;
-debug_report_data *report_data = VK_NULL_HANDLE;
-
-std::unordered_map<void *, layer_data *> layer_data_map;
-std::unordered_map<void *, instance_layer_data *> instance_layer_data_map;
-
-// Create an object_lifetime object and add it to the global_interceptor_list
-#include "interceptor_objects.h"
-ObjectLifetimes object_tracker_object;
+// Include child object (layer) definitions
+#include "object_lifetime_validation.h"
namespace vulkan_layer_chassis {
@@ -185,32 +180,30 @@
// Manually written functions
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) {
- assert(device);
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
const auto &item = name_to_funcptr_map.find(funcName);
if (item != name_to_funcptr_map.end()) {
return reinterpret_cast<PFN_vkVoidFunction>(item->second);
}
- auto &table = device_data->dispatch_table;
+ auto &table = layer_data->device_dispatch_table;
if (!table.GetDeviceProcAddr) return nullptr;
return table.GetDeviceProcAddr(device, funcName);
}
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) {
- instance_layer_data *instance_data;
const auto &item = name_to_funcptr_map.find(funcName);
if (item != name_to_funcptr_map.end()) {
return reinterpret_cast<PFN_vkVoidFunction>(item->second);
}
- instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
- auto &table = instance_data->dispatch_table;
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ auto &table = layer_data->instance_dispatch_table;
if (!table.GetInstanceProcAddr) return nullptr;
return table.GetInstanceProcAddr(instance, funcName);
}
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
- instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
- auto &table = instance_data->dispatch_table;
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ auto &table = layer_data->instance_dispatch_table;
if (!table.GetPhysicalDeviceProcAddr) return nullptr;
return table.GetPhysicalDeviceProcAddr(instance, funcName);
}
@@ -235,16 +228,14 @@
VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName,
uint32_t *pCount, VkExtensionProperties *pProperties) {
if (pLayerName && !strcmp(pLayerName, global_layer.layerName)) return util_GetExtensionProperties(0, NULL, pCount, pProperties);
-
assert(physicalDevice);
-
- instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
- return instance_data->dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
+ return layer_data->instance_dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
}
VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
VkInstance *pInstance) {
- VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
+ VkLayerInstanceCreateInfo* chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
assert(chain_info->u.pLayerInfo);
PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
@@ -252,26 +243,37 @@
if (fpCreateInstance == NULL) return VK_ERROR_INITIALIZATION_FAILED;
chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
+ // Create temporary dispatch vector for pre-calls until instance is created
+ std::vector<ValidationObject*> local_object_dispatch;
+ auto object_tracker = new ObjectLifetimes;
+ local_object_dispatch.emplace_back(object_tracker);
+ object_tracker->container_type = LayerObjectTypeObjectTracker;
+
+
// Init dispatch array and call registration functions
- for (auto intercept : global_interceptor_list) {
+ for (auto intercept : local_object_dispatch) {
intercept->PreCallValidateCreateInstance(pCreateInfo, pAllocator, pInstance);
}
- for (auto intercept : global_interceptor_list) {
+ for (auto intercept : local_object_dispatch) {
intercept->PreCallRecordCreateInstance(pCreateInfo, pAllocator, pInstance);
}
VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
+ if (result != VK_SUCCESS) return result;
- 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->dispatch_table, fpGetInstanceProcAddr);
- instance_data->report_data = debug_utils_create_instance(
- &instance_data->dispatch_table, *pInstance, pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames);
- instance_data->extensions.InitFromInstanceCreateInfo((pCreateInfo->pApplicationInfo ? pCreateInfo->pApplicationInfo->apiVersion : VK_API_VERSION_1_0), pCreateInfo);
- layer_debug_messenger_actions(instance_data->report_data, instance_data->logging_messenger, pAllocator, "lunarg_object_tracker");
- report_data = instance_data->report_data;
+ auto framework = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map);
- for (auto intercept : global_interceptor_list) {
+ framework->object_dispatch = local_object_dispatch;
+
+ framework->instance = *pInstance;
+ layer_init_instance_dispatch_table(*pInstance, &framework->instance_dispatch_table, fpGetInstanceProcAddr);
+ framework->report_data = debug_utils_create_instance(&framework->instance_dispatch_table, *pInstance, pCreateInfo->enabledExtensionCount,
+ pCreateInfo->ppEnabledExtensionNames);
+ framework->api_version = framework->instance_extensions.InitFromInstanceCreateInfo(
+ (pCreateInfo->pApplicationInfo ? pCreateInfo->pApplicationInfo->apiVersion : VK_API_VERSION_1_0), pCreateInfo);
+ layer_debug_messenger_actions(framework->report_data, framework->logging_messenger, pAllocator, "lunarg_object_tracker");
+
+ for (auto intercept : framework->object_dispatch) {
intercept->PostCallRecordCreateInstance(pCreateInfo, pAllocator, pInstance);
}
@@ -280,95 +282,109 @@
VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(instance);
- instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map);
- for (auto intercept : global_interceptor_list) {
+ auto layer_data = GetLayerDataPtr(key, layer_data_map);
+ """ + precallvalidate_loop + """
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PreCallValidateDestroyInstance(instance, pAllocator);
}
- for (auto intercept : global_interceptor_list) {
+ """ + precallrecord_loop + """
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PreCallRecordDestroyInstance(instance, pAllocator);
}
- instance_data->dispatch_table.DestroyInstance(instance, pAllocator);
+ layer_data->instance_dispatch_table.DestroyInstance(instance, pAllocator);
- for (auto intercept : global_interceptor_list) {
+ """ + postcallrecord_loop + """
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PostCallRecordDestroyInstance(instance, pAllocator);
}
// Clean up logging callback, if any
- while (instance_data->logging_messenger.size() > 0) {
- VkDebugUtilsMessengerEXT messenger = instance_data->logging_messenger.back();
- layer_destroy_messenger_callback(instance_data->report_data, messenger, pAllocator);
- instance_data->logging_messenger.pop_back();
+ while (layer_data->logging_messenger.size() > 0) {
+ VkDebugUtilsMessengerEXT messenger = layer_data->logging_messenger.back();
+ layer_destroy_messenger_callback(layer_data->report_data, messenger, pAllocator);
+ layer_data->logging_messenger.pop_back();
}
- while (instance_data->logging_callback.size() > 0) {
- VkDebugReportCallbackEXT callback = instance_data->logging_callback.back();
- layer_destroy_report_callback(instance_data->report_data, callback, pAllocator);
- instance_data->logging_callback.pop_back();
+ while (layer_data->logging_callback.size() > 0) {
+ VkDebugReportCallbackEXT callback = layer_data->logging_callback.back();
+ layer_destroy_report_callback(layer_data->report_data, callback, pAllocator);
+ layer_data->logging_callback.pop_back();
}
- for (auto intercept : global_interceptor_list) {
- intercept->PostCallRecordDestroyInstance(instance, pAllocator);
- }
- layer_debug_utils_destroy_instance(instance_data->report_data);
- FreeLayerDataPtr(key, instance_layer_data_map);
+
+ layer_debug_utils_destroy_instance(layer_data->report_data);
+
+ FreeLayerDataPtr(key, layer_data_map);
}
VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
- instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(gpu), instance_layer_data_map);
-
VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
+
+ auto instance_interceptor = GetLayerDataPtr(get_dispatch_key(gpu), layer_data_map);
+
PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
- PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(instance_data->instance, "vkCreateDevice");
+ PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(instance_interceptor->instance, "vkCreateDevice");
+ if (fpCreateDevice == NULL) {
+ return VK_ERROR_INITIALIZATION_FAILED;
+ }
chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
- for (auto intercept : global_interceptor_list) {
+ for (auto intercept : instance_interceptor->object_dispatch) {
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PreCallValidateCreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
}
- for (auto intercept : global_interceptor_list) {
+ for (auto intercept : instance_interceptor->object_dispatch) {
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PreCallRecordCreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
}
VkResult result = fpCreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
+ if (result != VK_SUCCESS) {
+ return result;
+ }
- for (auto intercept : global_interceptor_list) {
+ auto device_interceptor = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map);
+ layer_init_device_dispatch_table(*pDevice, &device_interceptor->device_dispatch_table, fpGetDeviceProcAddr);
+ device_interceptor->device = *pDevice;
+ device_interceptor->physical_device = gpu;
+ device_interceptor->instance = instance_interceptor->instance;
+ device_interceptor->report_data = layer_debug_utils_create_device(instance_interceptor->report_data, *pDevice);
+ device_interceptor->api_version = instance_interceptor->api_version;
+
+ // Create child layer objects for this key and add to dispatch vector
+ auto object_tracker = new ObjectLifetimes;
+ // TODO: Initialize child objects with parent info thru constuctor taking a parent object
+ object_tracker->container_type = LayerObjectTypeObjectTracker;
+ object_tracker->physical_device = gpu;
+ object_tracker->instance = instance_interceptor->instance;
+ object_tracker->report_data = device_interceptor->report_data;
+ object_tracker->device_dispatch_table = device_interceptor->device_dispatch_table;
+ device_interceptor->object_dispatch.emplace_back(object_tracker);
+
+ for (auto intercept : instance_interceptor->object_dispatch) {
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PostCallRecordCreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
}
- layer_data *device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map);
- device_data->instance_data = instance_data;
- layer_init_device_dispatch_table(*pDevice, &device_data->dispatch_table, fpGetDeviceProcAddr);
- device_data->device = *pDevice;
- device_data->physical_device = gpu;
- device_data->report_data = layer_debug_utils_create_device(instance_data->report_data, *pDevice);
- VkPhysicalDeviceProperties physical_device_properties{};
- instance_data->dispatch_table.GetPhysicalDeviceProperties(gpu, &physical_device_properties);
- device_data->extensions.InitFromDeviceCreateInfo(&instance_data->extensions, physical_device_properties.apiVersion, pCreateInfo);
return result;
}
VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(device);
- layer_data *device_data = GetLayerDataPtr(key, layer_data_map);
-
- for (auto intercept : global_interceptor_list) {
+ auto layer_data = GetLayerDataPtr(key, layer_data_map);
+ """ + precallvalidate_loop + """
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PreCallValidateDestroyDevice(device, pAllocator);
}
- for (auto intercept : global_interceptor_list) {
+ """ + precallrecord_loop + """
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PreCallRecordDestroyDevice(device, pAllocator);
}
layer_debug_utils_destroy_device(device);
- device_data->dispatch_table.DestroyDevice(device, pAllocator);
+ layer_data->device_dispatch_table.DestroyDevice(device, pAllocator);
- for (auto intercept : global_interceptor_list) {
+ """ + postcallrecord_loop + """
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PostCallRecordDestroyDevice(device, pAllocator);
}
@@ -380,18 +396,18 @@
const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDebugReportCallbackEXT *pCallback) {
- instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
- for (auto intercept : global_interceptor_list) {
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ """ + precallvalidate_loop + """
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PreCallValidateCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
}
- for (auto intercept : global_interceptor_list) {
+ """ + precallrecord_loop + """
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PreCallRecordCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
}
- VkResult result = instance_data->dispatch_table.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
- result = layer_create_report_callback(instance_data->report_data, false, pCreateInfo, pAllocator, pCallback);
- for (auto intercept : global_interceptor_list) {
+ VkResult result = layer_data->instance_dispatch_table.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
+ result = layer_create_report_callback(layer_data->report_data, false, pCreateInfo, pAllocator, pCallback);
+ """ + postcallrecord_loop + """
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PostCallRecordCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
}
@@ -400,18 +416,18 @@
VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks *pAllocator) {
- instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
- for (auto intercept : global_interceptor_list) {
+ auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
+ """ + precallvalidate_loop + """
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PreCallValidateDestroyDebugReportCallbackEXT(instance, callback, pAllocator);
}
- for (auto intercept : global_interceptor_list) {
+ """ + precallrecord_loop + """
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PreCallRecordDestroyDebugReportCallbackEXT(instance, callback, pAllocator);
}
- instance_data->dispatch_table.DestroyDebugReportCallbackEXT(instance, callback, pAllocator);
- layer_destroy_report_callback(instance_data->report_data, callback, pAllocator);
- for (auto intercept : global_interceptor_list) {
+ layer_data->instance_dispatch_table.DestroyDebugReportCallbackEXT(instance, callback, pAllocator);
+ layer_destroy_report_callback(layer_data->report_data, callback, pAllocator);
+ """ + postcallrecord_loop + """
std::lock_guard<std::mutex> lock(intercept->layer_mutex);
intercept->PostCallRecordDestroyDebugReportCallbackEXT(instance, callback, pAllocator);
}
@@ -528,6 +544,7 @@
if (genOpts.prefixText):
for s in genOpts.prefixText:
write(s, file=self.outFile)
+ write('#define NOMINMAX', file=self.outFile)
write('#include <mutex>', file=self.outFile)
write('#include <cinttypes>', file=self.outFile)
write('#include <stdio.h>', file=self.outFile)
@@ -535,6 +552,7 @@
write('#include <string.h>', file=self.outFile)
write('#include <unordered_map>', file=self.outFile)
write('#include <unordered_set>', file=self.outFile)
+ write('#include <algorithm>', file=self.outFile)
write('#include "vk_loader_platform.h"', file=self.outFile)
write('#include "vulkan/vulkan.h"', file=self.outFile)
@@ -551,59 +569,52 @@
write('#include "vk_validation_error_messages.h"', file=self.outFile)
write('#include "vk_extension_helper.h"', file=self.outFile)
write('', file=self.outFile)
-
-
- # TODO: Need some ifdef code here for which layer is being built!
- write('#include "object_lifetimes.h"', file=self.outFile)
- write('', file=self.outFile)
-
- write('struct instance_layer_data {', file=self.outFile)
- write(' VkLayerInstanceDispatchTable dispatch_table;', file=self.outFile)
- write(' VkInstance instance = VK_NULL_HANDLE;', file=self.outFile)
- write(' debug_report_data *report_data = nullptr;', file=self.outFile)
- write(' std::vector<VkDebugReportCallbackEXT> logging_callback;', file=self.outFile)
- write(' std::vector<VkDebugUtilsMessengerEXT> logging_messenger;', file=self.outFile)
- write(' InstanceExtensions extensions;', file=self.outFile)
- write('', file=self.outFile)
- # TODO: Need some ifdef code here for which layer is being built!
- write(' object_lifetime objdata;', file=self.outFile)
- write('};', file=self.outFile)
- write('', file=self.outFile)
- write('struct layer_data {', file=self.outFile)
- write(' debug_report_data *report_data = nullptr;', file=self.outFile)
- write(' VkLayerDispatchTable dispatch_table;', file=self.outFile)
- write(' DeviceExtensions extensions = {};', file=self.outFile)
- write(' VkDevice device = VK_NULL_HANDLE;', file=self.outFile)
- write(' VkPhysicalDevice physical_device = VK_NULL_HANDLE;', file=self.outFile)
- write(' instance_layer_data *instance_data = nullptr;', file=self.outFile)
- write('', file=self.outFile)
- # TODO: Need some ifdef code here for which layer is being built!
- write(' object_lifetime objdata;', file=self.outFile)
- write('};', file=self.outFile)
- write('', file=self.outFile)
- write('extern std::unordered_map<void *, layer_data *> layer_data_map;', file=self.outFile)
- write('extern std::unordered_map<void *, instance_layer_data *> instance_layer_data_map;', file=self.outFile)
- write('', file=self.outFile)
- write('class layer_chassis;', file=self.outFile)
- write('extern std::vector<layer_chassis *> global_interceptor_list;', file=self.outFile)
- write('extern debug_report_data *report_data;\n', file=self.outFile)
- write('namespace vulkan_layer_chassis {\n', file=self.outFile)
else:
write(self.inline_custom_source_preamble, file=self.outFile)
- # Initialize Enum Section
- self.layer_factory += '// Layer Factory base class definition\n'
- self.layer_factory += 'class layer_chassis {\n'
+ # Define some useful types
+ self.layer_factory += '// Layer object type identifiers\n'
+ self.layer_factory += 'enum LayerObjectTypeId {\n'
+ self.layer_factory += ' LayerObjectTypeThreading,\n'
+ self.layer_factory += ' LayerObjectTypeParameterValidation,\n'
+ self.layer_factory += ' LayerObjectTypeObjectTracker,\n'
+ self.layer_factory += ' LayerObjectTypeCoreValidation,\n'
+ self.layer_factory += ' LayerObjectTypeUniqueObjects,\n'
+ self.layer_factory += '};\n\n'
+
+ # Define base class
+ self.layer_factory += '// Uber Layer validation object base class definition\n'
+ self.layer_factory += 'class ValidationObject {\n'
self.layer_factory += ' public:\n'
- self.layer_factory += ' layer_chassis() {\n'
- self.layer_factory += ' global_interceptor_list.emplace_back(this);\n'
- self.layer_factory += ' };\n'
+ self.layer_factory += ' uint32_t api_version;\n'
+ self.layer_factory += ' debug_report_data* report_data = nullptr;\n'
+ self.layer_factory += ' std::vector<VkDebugReportCallbackEXT> logging_callback;\n'
+ self.layer_factory += ' std::vector<VkDebugUtilsMessengerEXT> logging_messenger;\n'
+ self.layer_factory += '\n'
+ self.layer_factory += ' VkLayerInstanceDispatchTable instance_dispatch_table;\n'
+ self.layer_factory += ' VkLayerDispatchTable device_dispatch_table;\n'
+ self.layer_factory += '\n'
+ self.layer_factory += ' InstanceExtensions instance_extensions;\n'
+ self.layer_factory += ' DeviceExtensions device_extensions = {};\n'
+ self.layer_factory += '\n'
+ self.layer_factory += ' VkInstance instance = VK_NULL_HANDLE;\n'
+ self.layer_factory += ' VkPhysicalDevice physical_device = VK_NULL_HANDLE;\n'
+ self.layer_factory += ' VkDevice device = VK_NULL_HANDLE;\n'
+ self.layer_factory += '\n'
+ self.layer_factory += ' std::vector<ValidationObject*> object_dispatch;\n'
+ self.layer_factory += ' LayerObjectTypeId container_type;\n'
+ self.layer_factory += '\n'
+ self.layer_factory += ' // Constructor\n'
+ self.layer_factory += ' ValidationObject(){};\n'
+ self.layer_factory += ' // Destructor\n'
+ self.layer_factory += ' virtual ~ValidationObject() {};\n'
self.layer_factory += '\n'
self.layer_factory += ' std::mutex layer_mutex;\n'
self.layer_factory += '\n'
self.layer_factory += ' std::string layer_name = "CHASSIS";\n'
self.layer_factory += '\n'
self.layer_factory += ' // Pre/post hook point declarations\n'
+
#
def endFile(self):
# Finish C++ namespace and multiple inclusion protection
@@ -615,11 +626,12 @@
write('\n'.join(self.intercepts), file=self.outFile)
write('};\n', file=self.outFile)
self.newline()
- write('} // namespace vulkan_layer_chassis', file=self.outFile)
+ write('} // namespace vulkan_layer_chassis', file=self.outFile)
if self.header:
self.newline()
# Output Layer Factory Class Definitions
- self.layer_factory += '};\n'
+ self.layer_factory += '};\n\n'
+ self.layer_factory += 'extern std::unordered_map<void*, ValidationObject*> layer_data_map;'
write(self.layer_factory, file=self.outFile)
else:
write(self.inline_custom_source_postamble, file=self.outFile)
@@ -761,18 +773,16 @@
dispatchable_name = cmdinfo.elem.find('param/name').text
# Default to device
device_or_instance = 'device'
- map_name = 'layer_data'
dispatch_table_name = 'VkLayerDispatchTable'
# Set to instance as necessary
if dispatchable_type in ["VkPhysicalDevice", "VkInstance"] or name == 'vkCreateInstance':
device_or_instance = 'instance'
dispatch_table_name = 'VkLayerInstanceDispatchTable'
- map_name = 'instance_layer_data'
- self.appendSection('command', ' %s *%s_data = GetLayerDataPtr(get_dispatch_key(%s), %s_map);' % (map_name, device_or_instance, dispatchable_name, map_name))
+ self.appendSection('command', ' auto layer_data = GetLayerDataPtr(get_dispatch_key(%s), layer_data_map);' % (dispatchable_name))
api_function_name = cmdinfo.elem.attrib.get('name')
params = cmdinfo.elem.findall('param/name')
paramstext = ', '.join([str(param.text) for param in params])
- API = api_function_name.replace('vk','%s_data->dispatch_table.' % (device_or_instance),1)
+ API = api_function_name.replace('vk','layer_data->%s_dispatch_table.' % (device_or_instance),1)
# Declare result variable, if any.
return_map = {
@@ -790,14 +800,14 @@
self.appendSection('command', ' bool skip = false;')
# Generate pre-call validation source code
- self.appendSection('command', ' for (auto intercept : global_interceptor_list) {')
+ self.appendSection('command', ' %s' % self.precallvalidate_loop)
self.appendSection('command', ' std::lock_guard<std::mutex> lock(intercept->layer_mutex);')
self.appendSection('command', ' skip |= intercept->PreCallValidate%s(%s);' % (api_function_name[2:], paramstext))
self.appendSection('command', ' if (skip) %s' % return_map[resulttype.text])
self.appendSection('command', ' }')
# Generate pre-call state recording source code
- self.appendSection('command', ' for (auto intercept : global_interceptor_list) {')
+ self.appendSection('command', ' %s' % self.precallrecord_loop)
self.appendSection('command', ' std::lock_guard<std::mutex> lock(intercept->layer_mutex);')
self.appendSection('command', ' intercept->PreCallRecord%s(%s);' % (api_function_name[2:], paramstext))
self.appendSection('command', ' }')
@@ -836,7 +846,8 @@
self.appendSection('command', ' if ((VK_SUCCESS == result) || (VK_INCOMPLETE == result)) {')
else:
self.appendSection('command', ' if (VK_SUCCESS == result) {')
- self.appendSection('command', '%s for (auto intercept : global_interceptor_list) {' % return_type_indent)
+
+ self.appendSection('command', '%s %s' % (return_type_indent, self.postcallrecord_loop))
self.appendSection('command', '%s std::lock_guard<std::mutex> lock(intercept->layer_mutex);' % return_type_indent)
self.appendSection('command', '%s intercept->PostCallRecord%s(%s);' % (return_type_indent,api_function_name[2:], paramstext))
self.appendSection('command', '%s }' % return_type_indent)
diff --git a/scripts/object_tracker_generator.py b/scripts/object_tracker_generator.py
index 2ca353b..974f9a7 100644
--- a/scripts/object_tracker_generator.py
+++ b/scripts/object_tracker_generator.py
@@ -397,7 +397,6 @@
self.newline()
self.otwrite('cpp', '#include "chassis.h"')
self.otwrite('cpp', '#include "object_lifetime_validation.h"')
- self.otwrite('cpp', '\n')
#
# Now that the data is all collected and complete, generate and output the object validation routines
@@ -696,11 +695,7 @@
object_dest = '%s[index]' % cmd_info[-1].name
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)
+ create_obj_code += '%sCreateObject(%s, %s, %s, %s);\n' % (indent, 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
@@ -729,12 +724,9 @@
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 += '%sskip |= %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))
+ validate_code += '%sskip |= 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 += '%sRecordDestroyObject(%s, %s, %s);\n' % (indent, 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
@@ -748,17 +740,14 @@
# 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 += '%sfor (uint32_t %s = 0; %s < %s; ++%s) {\n' % (indent, index, index, obj_count, index)
indent = self.incIndent(indent)
- pre_call_code += '%sskip |= %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)
+ pre_call_code += '%sskip |= 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)
indent = self.decIndent(indent)
pre_call_code += '%s}\n' % indent
else:
- pre_call_code += '%sskip |= %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)
+ pre_call_code += '%sskip |= 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)
return pre_call_code
#
# first_level_param indicates if elements are passed directly into the function else they're below a ptr/struct