OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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>
This commit is contained in:
Aaron Ruby
2024-04-26 18:44:50 -04:00
committed by Marge Bot
parent a1920507dc
commit fcb2b62bfe
4 changed files with 42 additions and 451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
src/gfxstream/codegen/scripts/cereal/functable.py
View File

@@ -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).
# Might need some special handling.
HANDLES_DONT_TRANSLATE = {
"VkSurfaceKHR",
## The following objects have no need for mesa counterparts
# Allows removal of handwritten create/destroy (for array).
"VkDescriptorSet",
# Bug in translation
"VkSampler",
"VkSamplerYcbcrConversion",
}
# Handles whose gfxstream object have non-base-object vk_ structs
# 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,
# Handles that need to be translated to/from their corresponding gfxstream object types
HANDLES_TRANSLATE = {
"VkInstance",
"VkPhysicalDevice",
"VkDevice",
"VkQueue",
"VkCommandPool",
"VkCommandBuffer",
"VkFence",
"VkSemaphore",
# TODO: What part of WSI needs Mesa object backings for VkImage/VkBuffer?
"VkBuffer",
"VkImage",
}
# 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,28 +276,17 @@ 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))
raise
# call vk_object_free() directly
mesaObjectDestroy = "(void *)%s" % objectName
cgen.funcCall(
None,
"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]
)
deviceParam = api.parameters[0]
if "VkDevice" != deviceParam.typeName:
print("ERROR: Unhandled non-VkDevice parameters[0]: %s (for API: %s)" %(deviceParam.typeName, api.name))
raise
# call vk_object_free() directly
mesaObjectDestroy = "(void *)%s" % objectName
cgen.funcCall(
None,
"vk_object_free",
["&%s->vk" % paramNameToObjectName(deviceParam.paramName), 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,10 +315,7 @@ 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)
genMesaObjectAlloc(callLhs)
retVar = api.getRetVarExpr()
if retVar:

253
src/gfxstream/guest/vulkan/gfxstream_vk_device.cpp
View File

@@ -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(
vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pAllocateInfo, pAllocator,
&gfxstream_pMemory->internal_object);
vkAllocateMemory_VkResult_return =
resources->on_vkAllocateMemory(vkEnc, VK_SUCCESS, gfxstream_device->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,
uint32_t descriptorSetCount,
DescriptorSetTransformStorage& storage) {
const VkWriteDescriptorSet* pDescriptorSets, uint32_t descriptorSetCount,
std::vector<std::vector<VkDescriptorBufferInfo>>& bufferInfos) {
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>());
storage.imageInfos[i].reserve(descriptorCount);
memset(&storage.imageInfos[i][0], 0, sizeof(VkDescriptorImageInfo) * 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);
bufferInfos.push_back(std::vector<VkDescriptorBufferInfo>());
bufferInfos[i].reserve(descriptorCount);
memset(&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];
storage.bufferInfos[i][j].buffer = VK_NULL_HANDLE;
bufferInfos[i][j] = srcBufferInfo[j];
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();
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();
outDescriptorSet.pBufferInfo = bufferInfos[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<VkWriteDescriptorSet> internal_pDescriptorWrites =
transformDescriptorSetList(pDescriptorWrites, descriptorWriteCount,
descriptorSetTransformStorage);
std::vector<std::vector<VkDescriptorBufferInfo>> descriptorBufferInfoStorage;
std::vector<VkWriteDescriptorSet> internal_pDescriptorWrites = transformDescriptorSetList(
pDescriptorWrites, descriptorWriteCount, descriptorBufferInfoStorage);
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 */);
}
}

17
src/gfxstream/guest/vulkan_enc/ResourceTracker.cpp
View File

@@ -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);
}

101
src/gfxstream/guest/vulkan_enc/gfxstream_vk_private.h
View File

@@ -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);