Merge changes Iae194bdc,Idba8e3f4 into main

* changes:
  Vulkan: fix dstArrayElement index wrap issue
  Add test for vkUpdateDescriptorSetWithTemplate() with wrapping

2 files changed, 173 insertions, 13 deletions

diff --git a/common/end2end/GfxstreamEnd2EndVkTests.cpp b/common/end2end/GfxstreamEnd2EndVkTests.cpp
index 6f2d6f66..e3c52a52 100644
--- a/common/end2end/GfxstreamEnd2EndVkTests.cpp
+++ b/common/end2end/GfxstreamEnd2EndVkTests.cpp
@@ -746,6 +746,129 @@ TEST_P(GfxstreamEnd2EndVkTest, DeviceMemoryReport) {
     ASSERT_THAT(memory, IsValidHandle());
 }
 
+TEST_P(GfxstreamEnd2EndVkTest, DescriptorUpdateTemplateWithWrapping) {
+    auto [instance, physicalDevice, device, queue, queueFamilyIndex] =
+        VK_ASSERT(SetUpTypicalVkTestEnvironment());
+
+    const vkhpp::BufferCreateInfo bufferCreateInfo = {
+        .size = 1024,
+        .usage = vkhpp::BufferUsageFlagBits::eUniformBuffer,
+    };
+    auto buffer = VK_ASSERT_RV(device->createBufferUnique(bufferCreateInfo));
+
+    const std::vector<VkDescriptorBufferInfo> descriptorInfo = {
+        VkDescriptorBufferInfo{
+            .buffer = *buffer,
+            .offset = 0,
+            .range = 1024,
+        },
+        VkDescriptorBufferInfo{
+            .buffer = *buffer,
+            .offset = 0,
+            .range = 1024,
+        },
+        VkDescriptorBufferInfo{
+            .buffer = *buffer,
+            .offset = 0,
+            .range = 1024,
+        },
+        VkDescriptorBufferInfo{
+            .buffer = *buffer,
+            .offset = 0,
+            .range = 1024,
+        },
+    };
+
+    const std::vector<vkhpp::DescriptorPoolSize> descriptorPoolSizes = {
+        {
+            .type = vkhpp::DescriptorType::eUniformBuffer,
+            .descriptorCount = 4,
+        },
+    };
+    const vkhpp::DescriptorPoolCreateInfo descriptorPoolCreateInfo = {
+        .flags = vkhpp::DescriptorPoolCreateFlagBits::eFreeDescriptorSet,
+        .maxSets = 1,
+        .poolSizeCount = static_cast<uint32_t>(descriptorPoolSizes.size()),
+        .pPoolSizes = descriptorPoolSizes.data(),
+    };
+    auto descriptorPool =
+        VK_ASSERT_RV(device->createDescriptorPoolUnique(descriptorPoolCreateInfo));
+
+    const std::vector<vkhpp::DescriptorSetLayoutBinding> descriptorSetBindings = {
+        {
+            .binding = 0,
+            .descriptorType = vkhpp::DescriptorType::eUniformBuffer,
+            .descriptorCount = 1,
+            .stageFlags = vkhpp::ShaderStageFlagBits::eVertex,
+        },
+        {
+            .binding = 1,
+            .descriptorType = vkhpp::DescriptorType::eUniformBuffer,
+            .descriptorCount = 1,
+            .stageFlags = vkhpp::ShaderStageFlagBits::eVertex,
+        },
+        {
+            .binding = 2,
+            .descriptorType = vkhpp::DescriptorType::eUniformBuffer,
+            .descriptorCount = 1,
+            .stageFlags = vkhpp::ShaderStageFlagBits::eVertex,
+        },
+        {
+            .binding = 3,
+            .descriptorType = vkhpp::DescriptorType::eUniformBuffer,
+            .descriptorCount = 1,
+            .stageFlags = vkhpp::ShaderStageFlagBits::eVertex,
+        },
+    };
+    const vkhpp::DescriptorSetLayoutCreateInfo descriptorSetLayoutInfo = {
+        .bindingCount = static_cast<uint32_t>(descriptorSetBindings.size()),
+        .pBindings = descriptorSetBindings.data(),
+    };
+    auto descriptorSetLayout =
+        VK_ASSERT_RV(device->createDescriptorSetLayoutUnique(descriptorSetLayoutInfo));
+
+    const std::vector<vkhpp::DescriptorSetLayout> descriptorSetLayouts = {*descriptorSetLayout};
+    const vkhpp::DescriptorSetAllocateInfo descriptorSetAllocateInfo = {
+        .descriptorPool = *descriptorPool,
+        .descriptorSetCount = static_cast<uint32_t>(descriptorSetLayouts.size()),
+        .pSetLayouts = descriptorSetLayouts.data(),
+    };
+    auto descriptorSets =
+        VK_ASSERT_RV(device->allocateDescriptorSetsUnique(descriptorSetAllocateInfo));
+    auto descriptorSet = std::move(descriptorSets[0]);
+
+    const vkhpp::PipelineLayoutCreateInfo pipelineLayoutCreateInfo = {
+        .setLayoutCount = static_cast<uint32_t>(descriptorSetLayouts.size()),
+        .pSetLayouts = descriptorSetLayouts.data(),
+    };
+    auto pipelineLayout =
+        VK_ASSERT_RV(device->createPipelineLayoutUnique(pipelineLayoutCreateInfo));
+
+    const std::vector<vkhpp::DescriptorUpdateTemplateEntry> descriptorUpdateEntries = {
+        {
+            .dstBinding = 0,
+            .dstArrayElement = 0,
+            .descriptorCount = 4,
+            .descriptorType = vkhpp::DescriptorType::eUniformBuffer,
+            .offset = 0,
+            .stride = sizeof(VkDescriptorBufferInfo),
+        },
+    };
+    const vkhpp::DescriptorUpdateTemplateCreateInfo descriptorUpdateTemplateCreateInfo = {
+        .descriptorUpdateEntryCount = static_cast<uint32_t>(descriptorUpdateEntries.size()),
+        .pDescriptorUpdateEntries = descriptorUpdateEntries.data(),
+        .descriptorSetLayout = *descriptorSetLayout,
+        .pipelineBindPoint = vkhpp::PipelineBindPoint::eGraphics,
+        .pipelineLayout = *pipelineLayout,
+        .set = 0,
+    };
+    auto descriptorUpdateTemplate = VK_ASSERT_RV(
+        device->createDescriptorUpdateTemplateUnique(descriptorUpdateTemplateCreateInfo));
+
+    device->updateDescriptorSetWithTemplate(*descriptorSet, *descriptorUpdateTemplate,
+                                            descriptorInfo.data());
+}
+
 std::vector<TestParams> GenerateTestCases() {
     std::vector<TestParams> cases = {TestParams{
                                          .with_gl = false,
diff --git a/guest/vulkan_enc/DescriptorSetVirtualization.cpp b/guest/vulkan_enc/DescriptorSetVirtualization.cpp
index d2389a47..5059e799 100644
--- a/guest/vulkan_enc/DescriptorSetVirtualization.cpp
+++ b/guest/vulkan_enc/DescriptorSetVirtualization.cpp
@@ -123,37 +123,52 @@ void doEmulatedDescriptorWrite(const VkWriteDescriptorSet* write, ReifiedDescrip
     uint32_t arrOffset = dstArrayElement;
 
     if (isDescriptorTypeImageInfo(descType)) {
-        for (uint32_t i = 0; i < descriptorCount; ++i, ++arrOffset) {
+        uint32_t i = 0;
+        while (i < descriptorCount) {
+            assert(dstBinding < table.size());
             if (arrOffset >= table[dstBinding].size()) {
                 ++dstBinding;
                 arrOffset = 0;
+                continue;
             }
             auto& entry = table[dstBinding][arrOffset];
             entry.imageInfo = write->pImageInfo[i];
             entry.type = DescriptorWriteType::ImageInfo;
             entry.descriptorType = descType;
+            ++i;
+            ++arrOffset;
         }
     } else if (isDescriptorTypeBufferInfo(descType)) {
-        for (uint32_t i = 0; i < descriptorCount; ++i, ++arrOffset) {
+        uint32_t i = 0;
+        while (i < descriptorCount) {
+            assert(dstBinding < table.size());
             if (arrOffset >= table[dstBinding].size()) {
                 ++dstBinding;
                 arrOffset = 0;
+                continue;
             }
             auto& entry = table[dstBinding][arrOffset];
             entry.bufferInfo = write->pBufferInfo[i];
             entry.type = DescriptorWriteType::BufferInfo;
             entry.descriptorType = descType;
+            ++i;
+            ++arrOffset;
         }
     } else if (isDescriptorTypeBufferView(descType)) {
-        for (uint32_t i = 0; i < descriptorCount; ++i, ++arrOffset) {
+        uint32_t i = 0;
+        while (i < descriptorCount) {
+            assert(dstBinding < table.size());
             if (arrOffset >= table[dstBinding].size()) {
                 ++dstBinding;
                 arrOffset = 0;
+                continue;
             }
             auto& entry = table[dstBinding][arrOffset];
             entry.bufferView = write->pTexelBufferView[i];
             entry.type = DescriptorWriteType::BufferView;
             entry.descriptorType = descType;
+            ++i;
+            ++arrOffset;
         }
     } else if (isDescriptorTypeInlineUniformBlock(descType)) {
         const VkWriteDescriptorSetInlineUniformBlock* descInlineUniformBlock =
@@ -196,22 +211,32 @@ void doEmulatedDescriptorCopy(const VkCopyDescriptorSet* copy, const ReifiedDesc
     std::vector<DescriptorWrite> toCopy;
     uint32_t currBinding = copy->srcBinding;
     uint32_t arrOffset = copy->srcArrayElement;
-    for (uint32_t i = 0; i < copy->descriptorCount; ++i, ++arrOffset) {
+    uint32_t i = 0;
+    while (i < copy->descriptorCount) {
+        assert(currBinding < srcTable.size());
         if (arrOffset >= srcTable[currBinding].size()) {
             ++currBinding;
             arrOffset = 0;
+            continue;
         }
         toCopy.push_back(srcTable[currBinding][arrOffset]);
+        ++i;
+        ++arrOffset;
     }
 
     currBinding = copy->dstBinding;
     arrOffset = copy->dstArrayElement;
-    for (uint32_t i = 0; i < copy->descriptorCount; ++i, ++arrOffset) {
+    i = 0;
+    while (i < copy->descriptorCount) {
+        assert(currBinding < dstTable.size());
         if (arrOffset >= dstTable[currBinding].size()) {
             ++currBinding;
             arrOffset = 0;
+            continue;
         }
         dstTable[currBinding][arrOffset] = toCopy[i];
+        ++i;
+        ++arrOffset;
     }
 }
 
@@ -223,16 +248,20 @@ void doEmulatedDescriptorImageInfoWriteFromTemplate(VkDescriptorType descType, u
 
     uint32_t currBinding = binding;
     uint32_t arrOffset = dstArrayElement;
-
-    for (uint32_t i = 0; i < count; ++i, ++arrOffset) {
+    uint32_t i = 0;
+    while (i < count) {
+        assert(currBinding < table.size());
         if (arrOffset >= table[currBinding].size()) {
             ++currBinding;
             arrOffset = 0;
+            continue;
         }
         auto& entry = table[currBinding][arrOffset];
         entry.imageInfo = imageInfos[i];
         entry.type = DescriptorWriteType::ImageInfo;
         entry.descriptorType = descType;
+        ++i;
+        ++arrOffset;
     }
 }
 
@@ -244,16 +273,20 @@ void doEmulatedDescriptorBufferInfoWriteFromTemplate(VkDescriptorType descType,
 
     uint32_t currBinding = binding;
     uint32_t arrOffset = dstArrayElement;
-
-    for (uint32_t i = 0; i < count; ++i, ++arrOffset) {
+    uint32_t i = 0;
+    while (i < count) {
+        assert(currBinding < table.size());
         if (arrOffset >= table[currBinding].size()) {
             ++currBinding;
             arrOffset = 0;
+            continue;
         }
-        auto& entry = table[currBinding][dstArrayElement + i];
+        auto& entry = table[currBinding][arrOffset];
         entry.bufferInfo = bufferInfos[i];
         entry.type = DescriptorWriteType::BufferInfo;
         entry.descriptorType = descType;
+        ++i;
+        ++arrOffset;
     }
 }
 
@@ -265,16 +298,20 @@ void doEmulatedDescriptorBufferViewWriteFromTemplate(VkDescriptorType descType,
 
     uint32_t currBinding = binding;
     uint32_t arrOffset = dstArrayElement;
-
-    for (uint32_t i = 0; i < count; ++i, ++arrOffset) {
+    uint32_t i = 0;
+    while (i < count) {
+        assert(currBinding < table.size());
         if (arrOffset >= table[currBinding].size()) {
             ++currBinding;
             arrOffset = 0;
+            continue;
         }
-        auto& entry = table[currBinding][dstArrayElement + i];
+        auto& entry = table[currBinding][arrOffset];
         entry.bufferView = bufferViews[i];
         entry.type = DescriptorWriteType::BufferView;
         entry.descriptorType = descType;
+        ++i;
+        ++arrOffset;
     }
 }