layers:Track sparse image requirements

Add image state tracking for if sparse memory requirements have been
queried and when they are queried, save the requirements.

diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp
index db3a9e1..22c963d 100644 (file)
--- a/layers/core_validation.cpp
+++ b/layers/core_validation.cpp
@@ -4027,12 +4027,35 @@ VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(VkDevice device, const
     PostCallRecordGetImageMemoryRequirements(dev_data, pInfo->image, &pMemoryRequirements->memoryRequirements);
 }
 
+static void PostCallRecordGetImageSparseMemoryRequirements(IMAGE_STATE *image_state, uint32_t req_count,
+                                                           VkSparseImageMemoryRequirements *reqs) {
+    image_state->get_sparse_reqs_called = true;
+    image_state->sparse_requirements.resize(req_count);
+    if (reqs) {
+        std::copy(reqs, reqs + req_count, image_state->sparse_requirements.begin());
+    }
+}
+
 VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
                                                             VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
     // TODO : Implement tracking here, just passthrough initially
     layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     dev_data->dispatch_table.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount,
                                                               pSparseMemoryRequirements);
+    unique_lock_t lock(global_lock);
+    auto image_state = GetImageState(dev_data, image);
+    PostCallRecordGetImageSparseMemoryRequirements(image_state, *pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
+
+static void PostCallRecordGetImageSparseMemoryRequirements2KHR(IMAGE_STATE *image_state, uint32_t req_count,
+                                                               VkSparseImageMemoryRequirements2KHR *reqs) {
+    std::vector<VkSparseImageMemoryRequirements> sparse_reqs(req_count);
+    // Migrate to old struct type for common handling with GetImageSparseMemoryRequirements()
+    for (uint32_t i = 0; i < req_count; ++i) {
+        assert(!reqs[i].pNext);  // TODO: If an extension is ever added here we need to handle it
+        sparse_reqs[i] = reqs[i].memoryRequirements;
+    }
+    PostCallRecordGetImageSparseMemoryRequirements(image_state, req_count, sparse_reqs.data());
 }
 
 VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(VkDevice device,
@@ -4043,6 +4066,9 @@ VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(VkDevice device,
     layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     dev_data->dispatch_table.GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount,
                                                                   pSparseMemoryRequirements);
+    unique_lock_t lock(global_lock);
+    auto image_state = GetImageState(dev_data, pInfo->image);
+    PostCallRecordGetImageSparseMemoryRequirements2KHR(image_state, *pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 }
 
 VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,

diff --git a/layers/core_validation_types.h b/layers/core_validation_types.h
index c63d452..ee63188 100644 (file)
--- a/layers/core_validation_types.h
+++ b/layers/core_validation_types.h
@@ -248,8 +248,19 @@ class IMAGE_STATE : public BINDABLE {
     bool acquired;  // If this is a swapchain image, has it been acquired by the app.
     bool shared_presentable;  // True for a front-buffered swapchain image
     bool layout_locked;       // A front-buffered image that has been presented can never have layout transitioned
+    bool get_sparse_reqs_called;    // Track if GetImageSparseMemoryRequirements() has been called for this image
+    bool sparse_metadata_required;  // Track if sparse metadata aspect is required for this image
+    bool sparse_metadata_bound;     // Track if sparse metadata aspect is bound to this image
+    std::vector<VkSparseImageMemoryRequirements> sparse_requirements;
     IMAGE_STATE(VkImage img, const VkImageCreateInfo *pCreateInfo)
-        : image(img), createInfo(*pCreateInfo), valid(false), acquired(false), shared_presentable(false), layout_locked(false) {
+        : image(img),
+          createInfo(*pCreateInfo),
+          valid(false),
+          acquired(false),
+          shared_presentable(false),
+          layout_locked(false),
+          get_sparse_reqs_called(false),
+          sparse_requirements{} {
         if ((createInfo.sharingMode == VK_SHARING_MODE_CONCURRENT) && (createInfo.queueFamilyIndexCount > 0)) {
             uint32_t *pQueueFamilyIndices = new uint32_t[createInfo.queueFamilyIndexCount];
             for (uint32_t i = 0; i < createInfo.queueFamilyIndexCount; i++) {