gfxstream: Revert all unnecessary gfxstream_vk_* object types and corresponding translations in functable.

Original approach was to translate all possible handle types for complete
Mesa object equivalence. Practically, only a subset of these objects
actually need to be real Mesa objects for use with WSI. This simplifies
the translation and handwritten entries substantially, which is somewhat
brittle and bug-prone.

Clean up parts of functable.py that we don't need.

Reviewed-by: Aaron Ruby <aruby@blackberry.com>
Acked-by: Yonggang Luo <luoyonggang@gmail.com>
Acked-by: Adam Jackson <ajax@redhat.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/27246>

src/gfxstream/codegen/scripts/cereal/functable.py

@@ -111,7 +111,6 @@ HANDWRITTEN_ENTRY_POINTS = [
     "vkEnumeratePhysicalDeviceGroups",
     "vkCreateDevice",
     "vkDestroyDevice",
-    "vkCreateComputePipelines",
     # Manual alloc/free + vk_*_init/free() call w/ special params
     "vkGetDeviceQueue",
     "vkGetDeviceQueue2",
@@ -124,44 +123,23 @@ HANDWRITTEN_ENTRY_POINTS = [
     "vkResetCommandPool",
     # Special cases to handle struct translations in the pNext chain
     # TODO: Make a codegen module (use deepcopy as reference) to make this more robust
-    "vkCmdBeginRenderPass2KHR",
-    "vkCmdBeginRenderPass",
     "vkAllocateMemory",
     "vkUpdateDescriptorSets",
-    "vkQueueCommitDescriptorSetUpdatesGOOGLE",
 ]
 
-# TODO: handles with no equivalent gfxstream objects (yet).
+# Handles that need to be translated to/from their corresponding gfxstream object types
-#  Might need some special handling.
+HANDLES_TRANSLATE = {
-HANDLES_DONT_TRANSLATE = {
+    "VkInstance",
-    "VkSurfaceKHR",
+    "VkPhysicalDevice",
-    ## The following objects have no need for mesa counterparts
+    "VkDevice",
-    # Allows removal of handwritten create/destroy (for array).
+    "VkQueue",
-    "VkDescriptorSet",
+    "VkCommandPool",
-    # Bug in translation
+    "VkCommandBuffer",
-    "VkSampler",
+    "VkFence",
-    "VkSamplerYcbcrConversion",
+    "VkSemaphore",
-}
+    # TODO: What part of WSI needs Mesa object backings for VkImage/VkBuffer?
-
+    "VkBuffer",
-# Handles whose gfxstream object have non-base-object vk_ structs
+    "VkImage",
-# Optionally includes array of pairs of extraParams: {index, extraParam}
-# -1 means drop parameter of paramName specified by extraParam
-HANDLES_MESA_VK = {
-    # Handwritten handlers (added here for completeness)
-    "VkInstance" : None,
-    "VkPhysicalDevice" : None,
-    "VkDevice" : None,
-    "VkQueue" : None,
-    "VkCommandPool" : None,
-    "VkCommandBuffer" : None,
-    # Auto-generated creation/destroy
-    "VkDeviceMemory" : None,
-    "VkQueryPool" : None,
-    "VkBuffer" : [[-1, "pMemoryRequirements"]],
-    "VkBufferView" : None,
-    "VkImage" : [[-1, "pMemoryRequirements"]],
-    "VkImageView": [[1, "false /* driver_internal */"]],
-    "VkSampler" : None,
 }
 
 # Types that have a corresponding method for transforming
@@ -215,9 +193,6 @@ def typeNameToObjectType(typeName):
 def transformListFuncName(typeName):
     return "transform%sList" % (typeName)
 
-def hasMesaVkObject(typeName):
-    return typeName in HANDLES_MESA_VK
-
 def isAllocatorParam(param):
     ALLOCATOR_TYPE_NAME = "VkAllocationCallbacks"
     return (param.pointerIndirectionLevels == 1
@@ -278,7 +253,7 @@ class VulkanFuncTable(VulkanWrapperGenerator):
             return typeInfo.isCompoundType(typeName)
 
         def handleTranslationRequired(typeName):
-            return typeName in HANDLE_TYPES and typeName not in HANDLES_DONT_TRANSLATE
+            return typeName in HANDLE_TYPES and typeName in HANDLES_TRANSLATE
 
         def translationRequired(typeName):
             if isCompoundType(typeName):
@@ -301,7 +276,6 @@ class VulkanFuncTable(VulkanWrapperGenerator):
             for p in api.parameters:
                 if isAllocatorParam(p):
                     allocatorParam = p.paramName
-            if not hasMesaVkObject(destroyParam.typeName):
             deviceParam = api.parameters[0]
             if "VkDevice" != deviceParam.typeName:
                 print("ERROR: Unhandled non-VkDevice parameters[0]: %s (for API: %s)" %(deviceParam.typeName, api.name))
@@ -313,16 +287,6 @@ class VulkanFuncTable(VulkanWrapperGenerator):
                 "vk_object_free",
                 ["&%s->vk" % paramNameToObjectName(deviceParam.paramName), allocatorParam, mesaObjectDestroy]
             )
-            else:
-                baseName = typeNameToBaseName(destroyParam.typeName)
-                # objectName for destroy always at the back
-                mesaObjectPrimary = "&%s->vk" % paramNameToObjectName(api.parameters[0].paramName)
-                mesaObjectDestroy = "&%s->vk" % objectName
-                cgen.funcCall(
-                    None,
-                    "vk_%s_destroy" % (baseName),
-                    [mesaObjectPrimary, allocatorParam, mesaObjectDestroy]
-                )
 
         def genMesaObjectAlloc(allocCallLhs):
             deviceParam = api.parameters[0]
@@ -342,37 +306,6 @@ class VulkanFuncTable(VulkanWrapperGenerator):
                 ["&%s->vk" % paramNameToObjectName(deviceParam.paramName), allocatorParam, ("sizeof(%s)" % objectType), typeNameToVkObjectType(createParam.typeName)]
             )
 
-        def genMesaObjectCreate(createCallLhs):
-            def dropParam(params, drop):
-                for p in params:
-                    if p == drop:
-                        params.remove(p)
-                return params
-            createParam = getCreateParam(api)
-            objectType = "struct %s" % typeNameToObjectType(createParam.typeName)
-            modParams = copy.deepcopy(api.parameters)
-            # Mod params for the vk_%s_create() call i.e. vk_buffer_create()
-            for p in modParams:
-                if p.paramName == createParam.paramName:
-                    modParams.remove(p)
-                elif handleTranslationRequired(p.typeName):
-                    # Cast handle to the mesa type
-                    p.paramName = ("(%s*)%s" % (typeNameToMesaType(p.typeName), paramNameToObjectName(p.paramName)))
-            mesaCreateParams = [p.paramName for p in modParams] + ["sizeof(%s)" % objectType]
-            # Some special handling
-            extraParams = HANDLES_MESA_VK[createParam.typeName]
-            if extraParams:
-                for pair in extraParams:
-                    if -1 == pair[0]:
-                        mesaCreateParams = dropParam(mesaCreateParams, pair[1])
-                    else:
-                        mesaCreateParams.insert(pair[0], pair[1])
-            cgen.funcCall(
-                createCallLhs,
-                "(%s *)vk_%s_create" % (objectType, typeNameToBaseName(createParam.typeName)),
-                mesaCreateParams
-            )
-
         # Alloc/create gfxstream_vk_* object
         def genCreateGfxstreamObjects():
             createParam = getCreateParam(api)
@@ -382,9 +315,6 @@ class VulkanFuncTable(VulkanWrapperGenerator):
                 return False
             objectType = "struct %s" % typeNameToObjectType(createParam.typeName)
             callLhs = "%s *%s" % (objectType, paramNameToObjectName(createParam.paramName))
-            if hasMesaVkObject(createParam.typeName):
-                genMesaObjectCreate(callLhs)
-            else:
             genMesaObjectAlloc(callLhs)
 
             retVar = api.getRetVarExpr()

src/gfxstream/guest/vulkan/gfxstream_vk_device.cpp

@@ -645,10 +645,6 @@ VkResult gfxstream_vk_AllocateMemory(VkDevice device, const VkMemoryAllocateInfo
     AEMU_SCOPED_TRACE("vkAllocateMemory");
     VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
     VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
-    struct gfxstream_vk_device_memory* gfxstream_pMemory =
-        (struct gfxstream_vk_device_memory*)vk_device_memory_create(
-            (vk_device*)gfxstream_device, pAllocateInfo, pAllocator,
-            sizeof(struct gfxstream_vk_device_memory));
     /* VkMemoryDedicatedAllocateInfo */
     VkMemoryDedicatedAllocateInfo* dedicatedAllocInfoPtr =
         (VkMemoryDedicatedAllocateInfo*)vk_find_struct<VkMemoryDedicatedAllocateInfo>(
@@ -663,103 +659,16 @@ VkResult gfxstream_vk_AllocateMemory(VkDevice device, const VkMemoryAllocateInfo
             dedicatedAllocInfoPtr->image = gfxstream_image->internal_object;
         }
     }
-    vkAllocateMemory_VkResult_return = gfxstream_pMemory ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    {
-    if (VK_SUCCESS == vkAllocateMemory_VkResult_return) {
         auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
         auto resources = gfxstream::vk::ResourceTracker::get();
-        vkAllocateMemory_VkResult_return = resources->on_vkAllocateMemory(
+        vkAllocateMemory_VkResult_return =
-            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pAllocateInfo, pAllocator,
+            resources->on_vkAllocateMemory(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
-            &gfxstream_pMemory->internal_object);
+                                           pAllocateInfo, pAllocator, pMemory);
     }
-    *pMemory = gfxstream_vk_device_memory_to_handle(gfxstream_pMemory);
     return vkAllocateMemory_VkResult_return;
 }
 
-void gfxstream_vk_CmdBeginRenderPass(VkCommandBuffer commandBuffer,
-                                     const VkRenderPassBeginInfo* pRenderPassBegin,
-                                     VkSubpassContents contents) {
-    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass");
-    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
-    {
-        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
-            gfxstream_commandBuffer->internal_object);
-        VkRenderPassBeginInfo internal_pRenderPassBegin = vk_make_orphan_copy(*pRenderPassBegin);
-        vk_struct_chain_iterator structChainIter =
-            vk_make_chain_iterator(&internal_pRenderPassBegin);
-        /* VkRenderPassBeginInfo::renderPass */
-        VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
-                       internal_pRenderPassBegin.renderPass);
-        internal_pRenderPassBegin.renderPass = gfxstream_renderPass->internal_object;
-        /* VkRenderPassBeginInfo::framebuffer */
-        VK_FROM_HANDLE(gfxstream_vk_framebuffer, gfxstream_framebuffer,
-                       internal_pRenderPassBegin.framebuffer);
-        internal_pRenderPassBegin.framebuffer = gfxstream_framebuffer->internal_object;
-        /* pNext = VkRenderPassAttachmentBeginInfo */
-        std::vector<VkImageView> internal_pAttachments;
-        VkRenderPassAttachmentBeginInfo internal_renderPassAttachmentBeginInfo;
-        VkRenderPassAttachmentBeginInfo* pRenderPassAttachmentBeginInfo =
-            (VkRenderPassAttachmentBeginInfo*)vk_find_struct<VkRenderPassAttachmentBeginInfo>(
-                pRenderPassBegin);
-        if (pRenderPassAttachmentBeginInfo) {
-            internal_renderPassAttachmentBeginInfo = *pRenderPassAttachmentBeginInfo;
-            /* VkRenderPassAttachmentBeginInfo::pAttachments */
-            internal_pAttachments.reserve(internal_renderPassAttachmentBeginInfo.attachmentCount);
-            for (uint32_t i = 0; i < internal_renderPassAttachmentBeginInfo.attachmentCount; i++) {
-                VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_image_view,
-                               internal_renderPassAttachmentBeginInfo.pAttachments[i]);
-                internal_pAttachments[i] = gfxstream_image_view->internal_object;
-            }
-            internal_renderPassAttachmentBeginInfo.pAttachments = internal_pAttachments.data();
-            vk_append_struct(&structChainIter, &internal_renderPassAttachmentBeginInfo);
-        }
-        vkEnc->vkCmdBeginRenderPass(gfxstream_commandBuffer->internal_object,
-                                    &internal_pRenderPassBegin, contents, true /* do lock */);
-    }
-}
-
-void gfxstream_vk_CmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
-                                         const VkRenderPassBeginInfo* pRenderPassBegin,
-                                         const VkSubpassBeginInfo* pSubpassBeginInfo) {
-    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
-    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
-    {
-        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
-            gfxstream_commandBuffer->internal_object);
-        VkRenderPassBeginInfo internal_pRenderPassBegin = vk_make_orphan_copy(*pRenderPassBegin);
-        vk_struct_chain_iterator structChainIter =
-            vk_make_chain_iterator(&internal_pRenderPassBegin);
-        /* VkRenderPassBeginInfo::renderPass */
-        VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
-                       internal_pRenderPassBegin.renderPass);
-        internal_pRenderPassBegin.renderPass = gfxstream_renderPass->internal_object;
-        /* VkRenderPassBeginInfo::framebuffer */
-        VK_FROM_HANDLE(gfxstream_vk_framebuffer, gfxstream_framebuffer,
-                       internal_pRenderPassBegin.framebuffer);
-        internal_pRenderPassBegin.framebuffer = gfxstream_framebuffer->internal_object;
-        /* pNext = VkRenderPassAttachmentBeginInfo */
-        std::vector<VkImageView> internal_pAttachments;
-        VkRenderPassAttachmentBeginInfo internal_renderPassAttachmentBeginInfo;
-        VkRenderPassAttachmentBeginInfo* pRenderPassAttachmentBeginInfo =
-            (VkRenderPassAttachmentBeginInfo*)vk_find_struct<VkRenderPassAttachmentBeginInfo>(
-                pRenderPassBegin);
-        if (pRenderPassAttachmentBeginInfo) {
-            internal_renderPassAttachmentBeginInfo = *pRenderPassAttachmentBeginInfo;
-            /* VkRenderPassAttachmentBeginInfo::pAttachments */
-            internal_pAttachments.reserve(internal_renderPassAttachmentBeginInfo.attachmentCount);
-            for (uint32_t i = 0; i < internal_renderPassAttachmentBeginInfo.attachmentCount; i++) {
-                VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_image_view,
-                               internal_renderPassAttachmentBeginInfo.pAttachments[i]);
-                internal_pAttachments[i] = gfxstream_image_view->internal_object;
-            }
-            internal_renderPassAttachmentBeginInfo.pAttachments = internal_pAttachments.data();
-            vk_append_struct(&structChainIter, &internal_renderPassAttachmentBeginInfo);
-        }
-        vkEnc->vkCmdBeginRenderPass2KHR(gfxstream_commandBuffer->internal_object,
-                                        &internal_pRenderPassBegin, pSubpassBeginInfo,
-                                        true /* do lock */);
-    }
-}
-
 VkResult gfxstream_vk_EnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
                                                        VkLayerProperties* pProperties) {
     AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties");
@@ -794,69 +703,9 @@ VkResult gfxstream_vk_EnumerateInstanceVersion(uint32_t* pApiVersion) {
     return vkEnumerateInstanceVersion_VkResult_return;
 }
 
-VkResult gfxstream_vk_CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
-                                             uint32_t createInfoCount,
-                                             const VkComputePipelineCreateInfo* pCreateInfos,
-                                             const VkAllocationCallbacks* pAllocator,
-                                             VkPipeline* pPipelines) {
-    AEMU_SCOPED_TRACE("vkCreateComputePipelines");
-    VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
-    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
-    VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
-    struct gfxstream_vk_pipeline* gfxstream_pPipelines = (gfxstream_vk_pipeline*)vk_object_zalloc(
-        &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_pipeline), VK_OBJECT_TYPE_PIPELINE);
-    vkCreateComputePipelines_VkResult_return =
-        gfxstream_pPipelines ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
-    if (VK_SUCCESS == vkCreateComputePipelines_VkResult_return) {
-        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
-        std::vector<VkComputePipelineCreateInfo> internal_pCreateInfos(createInfoCount);
-        std::vector<VkPipelineShaderStageCreateInfo> internal_VkComputePipelineCreateInfo_stage(createInfoCount);
-        for (uint32_t i = 0; i < createInfoCount; ++i) {
-            internal_pCreateInfos[i] = pCreateInfos[i];
-            /* VkComputePipelineCreateInfo::stage */
-            {
-                internal_VkComputePipelineCreateInfo_stage[i] = internal_pCreateInfos[i].stage;
-                /* VkPipelineShaderStageCreateInfo::module */
-                if (internal_VkComputePipelineCreateInfo_stage[i].module) {
-                    VK_FROM_HANDLE(gfxstream_vk_shader_module, gfxstream_module,
-                                   internal_VkComputePipelineCreateInfo_stage[i].module);
-                    internal_VkComputePipelineCreateInfo_stage[i].module =
-                        gfxstream_module->internal_object;
-                }
-                internal_pCreateInfos[i].stage = internal_VkComputePipelineCreateInfo_stage[i];
-            }
-            /* VkComputePipelineCreateInfo::layout */
-            VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout,
-                           internal_pCreateInfos[i].layout);
-            internal_pCreateInfos[i].layout = gfxstream_layout->internal_object;
-            /* VkComputePipelineCreateInfo::basePipelineHandle */
-            if (internal_pCreateInfos[i].basePipelineHandle) {
-                VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_basePipelineHandle,
-                               internal_pCreateInfos[i].basePipelineHandle);
-                internal_pCreateInfos[i].basePipelineHandle =
-                    gfxstream_basePipelineHandle->internal_object;
-            }
-        }
-        vkCreateComputePipelines_VkResult_return = vkEnc->vkCreateComputePipelines(
-            gfxstream_device->internal_object,
-            gfxstream_pipelineCache ? gfxstream_pipelineCache->internal_object : VK_NULL_HANDLE,
-            createInfoCount, internal_pCreateInfos.data(), pAllocator,
-            &gfxstream_pPipelines->internal_object, true /* do lock */);
-    }
-    *pPipelines = gfxstream_vk_pipeline_to_handle(gfxstream_pPipelines);
-    return vkCreateComputePipelines_VkResult_return;
-}
-
-struct DescriptorSetTransformStorage {
-    std::vector<std::vector<VkDescriptorImageInfo>> imageInfos;
-    std::vector<std::vector<VkDescriptorBufferInfo>> bufferInfos;
-    std::vector<std::vector<VkBufferView>> texelBuffers;
-};
-
 static std::vector<VkWriteDescriptorSet> transformDescriptorSetList(
-    const VkWriteDescriptorSet* pDescriptorSets,
+    const VkWriteDescriptorSet* pDescriptorSets, uint32_t descriptorSetCount,
-    uint32_t descriptorSetCount,
+    std::vector<std::vector<VkDescriptorBufferInfo>>& bufferInfos) {
-    DescriptorSetTransformStorage& storage) {
     std::vector<VkWriteDescriptorSet> outDescriptorSets(descriptorSetCount);
     for (uint32_t i = 0; i < descriptorSetCount; ++i) {
         const auto& srcDescriptorSet = pDescriptorSets[i];
@@ -865,54 +714,22 @@ static std::vector<VkWriteDescriptorSet> transformDescriptorSetList(
         VkWriteDescriptorSet& outDescriptorSet = outDescriptorSets[i];
         outDescriptorSet = srcDescriptorSet;
 
-        storage.imageInfos.push_back(std::vector<VkDescriptorImageInfo>());
+        bufferInfos.push_back(std::vector<VkDescriptorBufferInfo>());
-        storage.imageInfos[i].reserve(descriptorCount);
+        bufferInfos[i].reserve(descriptorCount);
-        memset(&storage.imageInfos[i][0], 0, sizeof(VkDescriptorImageInfo) * descriptorCount);
+        memset(&bufferInfos[i][0], 0, sizeof(VkDescriptorBufferInfo) * descriptorCount);
-        for (uint32_t j = 0; j < descriptorCount; ++j) {
-            const auto* srcImageInfo = srcDescriptorSet.pImageInfo;
-            if (srcImageInfo) {
-                storage.imageInfos[i][j] = srcImageInfo[j];
-                storage.imageInfos[i][j].imageView = VK_NULL_HANDLE;
-                if (vk_descriptor_type_has_image_view(srcDescriptorSet.descriptorType) &&
-                    srcImageInfo[j].imageView) {
-                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstreamImageView,
-                                   srcImageInfo[j].imageView);
-                    storage.imageInfos[i][j].imageView = gfxstreamImageView->internal_object;
-                }
-            }
-        }
-        outDescriptorSet.pImageInfo = storage.imageInfos[i].data();
-
-        storage.bufferInfos.push_back(std::vector<VkDescriptorBufferInfo>());
-        storage.bufferInfos[i].reserve(descriptorCount);
-        memset(&storage.bufferInfos[i][0], 0, sizeof(VkDescriptorBufferInfo) * descriptorCount);
         for (uint32_t j = 0; j < descriptorCount; ++j) {
             const auto* srcBufferInfo = srcDescriptorSet.pBufferInfo;
             if (srcBufferInfo) {
-                storage.bufferInfos[i][j] = srcBufferInfo[j];
+                bufferInfos[i][j] = srcBufferInfo[j];
-                storage.bufferInfos[i][j].buffer = VK_NULL_HANDLE;
+                bufferInfos[i][j].buffer = VK_NULL_HANDLE;
                 if (vk_descriptor_type_has_descriptor_buffer(srcDescriptorSet.descriptorType) &&
                     srcBufferInfo[j].buffer) {
                     VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstreamBuffer, srcBufferInfo[j].buffer);
-                    storage.bufferInfos[i][j].buffer = gfxstreamBuffer->internal_object;
+                    bufferInfos[i][j].buffer = gfxstreamBuffer->internal_object;
                 }
             }
         }
-        outDescriptorSet.pBufferInfo = storage.bufferInfos[i].data();
+        outDescriptorSet.pBufferInfo = bufferInfos[i].data();
-
-        storage.texelBuffers.push_back(std::vector<VkBufferView>());
-        storage.texelBuffers[i].reserve(descriptorCount);
-        memset(&storage.texelBuffers[i][0], 0, sizeof(VkBufferView) * descriptorCount);
-        for (uint32_t j = 0; j < descriptorCount; ++j) {
-            const auto* srcBufferView = srcDescriptorSet.pTexelBufferView;
-            if (vk_descriptor_type_has_texel_buffer(srcDescriptorSet.descriptorType) &&
-                srcBufferView) {
-                VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstreamBufferView, srcBufferView[j]);
-                storage.texelBuffers[i][j] =
-                    gfxstreamBufferView->internal_object;
-            }
-        }
-        outDescriptorSet.pTexelBufferView = storage.texelBuffers[i].data();
     }
     return outDescriptorSets;
 }
@@ -925,50 +742,12 @@ void gfxstream_vk_UpdateDescriptorSets(VkDevice device, uint32_t descriptorWrite
     VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
     {
         auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
-        DescriptorSetTransformStorage descriptorSetTransformStorage;
+        std::vector<std::vector<VkDescriptorBufferInfo>> descriptorBufferInfoStorage;
-        std::vector<VkWriteDescriptorSet> internal_pDescriptorWrites =
+        std::vector<VkWriteDescriptorSet> internal_pDescriptorWrites = transformDescriptorSetList(
-            transformDescriptorSetList(pDescriptorWrites, descriptorWriteCount,
+            pDescriptorWrites, descriptorWriteCount, descriptorBufferInfoStorage);
-                                       descriptorSetTransformStorage);
         auto resources = gfxstream::vk::ResourceTracker::get();
         resources->on_vkUpdateDescriptorSets(
             vkEnc, gfxstream_device->internal_object, descriptorWriteCount,
             internal_pDescriptorWrites.data(), descriptorCopyCount, pDescriptorCopies);
     }
 }
-
-void gfxstream_vk_QueueCommitDescriptorSetUpdatesGOOGLE(
-    VkQueue queue, uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools,
-    uint32_t descriptorSetCount, const VkDescriptorSetLayout* pSetLayouts,
-    const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool,
-    const uint32_t* pDescriptorSetPendingAllocation,
-    const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount,
-    const VkWriteDescriptorSet* pPendingDescriptorWrites) {
-    AEMU_SCOPED_TRACE("vkQueueCommitDescriptorSetUpdatesGOOGLE");
-    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
-    {
-        auto vkEnc =
-            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
-        std::vector<VkDescriptorPool> internal_pDescriptorPools(descriptorPoolCount);
-        for (uint32_t i = 0; i < descriptorPoolCount; ++i) {
-            VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_pDescriptorPools,
-                           pDescriptorPools[i]);
-            internal_pDescriptorPools[i] = gfxstream_pDescriptorPools->internal_object;
-        }
-        std::vector<VkDescriptorSetLayout> internal_pSetLayouts(descriptorSetCount);
-        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
-            VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_pSetLayouts,
-                           pSetLayouts[i]);
-            internal_pSetLayouts[i] = gfxstream_pSetLayouts->internal_object;
-        }
-        DescriptorSetTransformStorage descriptorSetTransformStorage;
-        std::vector<VkWriteDescriptorSet> internal_pPendingDescriptorWrites =
-            transformDescriptorSetList(pPendingDescriptorWrites, pendingDescriptorWriteCount,
-                                       descriptorSetTransformStorage);
-        vkEnc->vkQueueCommitDescriptorSetUpdatesGOOGLE(
-            gfxstream_queue->internal_object, descriptorPoolCount, internal_pDescriptorPools.data(),
-            descriptorSetCount, internal_pSetLayouts.data(), pDescriptorSetPoolIds,
-            pDescriptorSetWhichPool, pDescriptorSetPendingAllocation,
-            pDescriptorWriteStartingIndices, pendingDescriptorWriteCount,
-            internal_pPendingDescriptorWrites.data(), true /* do lock */);
-    }
-}

src/gfxstream/guest/vulkan_enc/ResourceTracker.cpp

@@ -6364,14 +6364,6 @@ void ResourceTracker::on_vkUpdateDescriptorSetWithTemplate(
 
                 memcpy(((uint8_t*)imageInfos) + currImageInfoOffset, user,
                        sizeof(VkDescriptorImageInfo));
-#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
-                // Convert mesa to internal for objects in the user buffer
-                VkDescriptorImageInfo* internalImageInfo =
-                    (VkDescriptorImageInfo*)(((uint8_t*)imageInfos) + currImageInfoOffset);
-                VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_image_view,
-                               internalImageInfo->imageView);
-                internalImageInfo->imageView = gfxstream_image_view->internal_object;
-#endif
                 currImageInfoOffset += sizeof(VkDescriptorImageInfo);
             }
 
@@ -6416,15 +6408,6 @@ void ResourceTracker::on_vkUpdateDescriptorSetWithTemplate(
                 const VkBufferView* user = (const VkBufferView*)(userBuffer + offset + j * stride);
 
                 memcpy(((uint8_t*)bufferViews) + currBufferViewOffset, user, sizeof(VkBufferView));
-#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
-                // Convert mesa to internal for objects in the user buffer
-                VkBufferView* internalBufferView =
-                    (VkBufferView*)(((uint8_t*)bufferViews) + currBufferViewOffset);
-                VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_buffer_view,
-                               *internalBufferView);
-                *internalBufferView = gfxstream_buffer_view->internal_object;
-#endif
-
                 currBufferViewOffset += sizeof(VkBufferView);
             }
 

src/gfxstream/guest/vulkan_enc/gfxstream_vk_private.h

@@ -43,12 +43,9 @@
 #include "gfxstream_vk_entrypoints.h"
 #include "vk_alloc.h"
 #include "vk_buffer.h"
-#include "vk_buffer_view.h"
 #include "vk_command_buffer.h"
 #include "vk_command_pool.h"
-#include "vk_descriptor_update_template.h"
 #include "vk_device.h"
-#include "vk_device_memory.h"
 #include "vk_extensions.h"
 #include "vk_fence.h"
 #include "vk_image.h"
@@ -56,7 +53,6 @@
 #include "vk_log.h"
 #include "vk_object.h"
 #include "vk_physical_device.h"
-#include "vk_query_pool.h"
 #include "vk_queue.h"
 #include "vk_semaphore.h"
 #include "vulkan/wsi/wsi_common.h"
@@ -90,31 +86,6 @@ struct gfxstream_vk_queue {
     VkQueue internal_object;
 };
 
-struct gfxstream_vk_pipeline_cache {
-    struct vk_object_base base;
-    VkPipelineCache internal_object;
-};
-
-struct gfxstream_vk_device_memory {
-    struct vk_device_memory vk;
-    VkDeviceMemory internal_object;
-};
-
-struct gfxstream_vk_descriptor_set_layout {
-    struct vk_object_base base;
-    VkDescriptorSetLayout internal_object;
-};
-
-struct gfxstream_vk_pipeline_layout {
-    struct vk_object_base base;
-    VkPipelineLayout internal_object;
-};
-
-struct gfxstream_vk_descriptor_pool {
-    struct vk_object_base base;
-    VkDescriptorPool internal_object;
-};
-
 struct gfxstream_vk_buffer {
     struct vk_buffer vk;
     VkBuffer internal_object;
@@ -130,41 +101,11 @@ struct gfxstream_vk_command_buffer {
     VkCommandBuffer internal_object;
 };
 
-struct gfxstream_vk_event {
-    struct vk_object_base base;
-    VkEvent internal_object;
-};
-
-struct gfxstream_vk_pipeline {
-    struct vk_object_base base;
-    VkPipeline internal_object;
-};
-
 struct gfxstream_vk_image {
     struct vk_image vk;
     VkImage internal_object;
 };
 
-struct gfxstream_vk_image_view {
-    struct vk_image_view vk;
-    VkImageView internal_object;
-};
-
-struct gfxstream_vk_buffer_view {
-    struct vk_buffer_view vk;
-    VkBufferView internal_object;
-};
-
-struct gfxstream_vk_framebuffer {
-    struct vk_object_base base;
-    VkFramebuffer internal_object;
-};
-
-struct gfxstream_vk_render_pass {
-    struct vk_object_base base;
-    VkRenderPass internal_object;
-};
-
 struct gfxstream_vk_fence {
     struct vk_fence vk;
     VkFence internal_object;
@@ -175,21 +116,6 @@ struct gfxstream_vk_semaphore {
     VkSemaphore internal_object;
 };
 
-struct gfxstream_vk_query_pool {
-    struct vk_query_pool vk;
-    VkQueryPool internal_object;
-};
-
-struct gfxstream_vk_shader_module {
-    struct vk_object_base base;
-    VkShaderModule internal_object;
-};
-
-struct gfxstream_vk_descriptor_update_template {
-    struct vk_object_base base;
-    VkDescriptorUpdateTemplate internal_object;
-};
-
 VK_DEFINE_HANDLE_CASTS(gfxstream_vk_command_buffer, vk.base, VkCommandBuffer,
                        VK_OBJECT_TYPE_COMMAND_BUFFER)
 VK_DEFINE_HANDLE_CASTS(gfxstream_vk_device, vk.base, VkDevice, VK_OBJECT_TYPE_DEVICE)
@@ -201,37 +127,10 @@ VK_DEFINE_HANDLE_CASTS(gfxstream_vk_queue, vk.base, VkQueue, VK_OBJECT_TYPE_QUEU
 VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_command_pool, vk.base, VkCommandPool,
                                VK_OBJECT_TYPE_COMMAND_POOL)
 VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_buffer, vk.base, VkBuffer, VK_OBJECT_TYPE_BUFFER)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_buffer_view, vk.base, VkBufferView,
-                               VK_OBJECT_TYPE_BUFFER_VIEW)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_descriptor_pool, base, VkDescriptorPool,
-                               VK_OBJECT_TYPE_DESCRIPTOR_POOL)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_descriptor_set_layout, base, VkDescriptorSetLayout,
-                               VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_device_memory, vk.base, VkDeviceMemory,
-                               VK_OBJECT_TYPE_DEVICE_MEMORY)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_event, base, VkEvent, VK_OBJECT_TYPE_EVENT)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_framebuffer, base, VkFramebuffer,
-                               VK_OBJECT_TYPE_FRAMEBUFFER)
 VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_image, vk.base, VkImage, VK_OBJECT_TYPE_IMAGE)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_image_view, vk.base, VkImageView,
-                               VK_OBJECT_TYPE_IMAGE_VIEW);
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_pipeline_cache, base, VkPipelineCache,
-                               VK_OBJECT_TYPE_PIPELINE_CACHE)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_pipeline, base, VkPipeline, VK_OBJECT_TYPE_PIPELINE)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_pipeline_layout, base, VkPipelineLayout,
-                               VK_OBJECT_TYPE_PIPELINE_LAYOUT)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_render_pass, base, VkRenderPass,
-                               VK_OBJECT_TYPE_RENDER_PASS)
 VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_fence, vk.base, VkFence, VK_OBJECT_TYPE_FENCE)
 VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_semaphore, vk.base, VkSemaphore,
                                VK_OBJECT_TYPE_SEMAPHORE)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_query_pool, vk.base, VkQueryPool,
-                               VK_OBJECT_TYPE_QUERY_POOL)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_shader_module, base, VkShaderModule,
-                               VK_OBJECT_TYPE_SHADER_MODULE)
-VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_descriptor_update_template, base,
-                               VkDescriptorUpdateTemplate,
-                               VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE)
 
 VkResult gfxstream_vk_wsi_init(struct gfxstream_vk_physical_device* physical_device);