From d8ba43984a874da57e7b118f9c6001846020df14 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 28 Feb 2022 13:07:53 -0300 Subject: [PATCH 1/5] vkr: update venus-protocol for proc tables Add the automatic generated code to the proc tables. Co-authored-by: Igor Torrente Co-authored-by: Chia-I Wu Part-of: --- .../venus-protocol/vn_protocol_renderer.h | 3 +- .../vn_protocol_renderer_util.h | 663 ++++++++++++++++++ 2 files changed, 665 insertions(+), 1 deletion(-) create mode 100644 src/venus/venus-protocol/vn_protocol_renderer_util.h diff --git a/src/venus/venus-protocol/vn_protocol_renderer.h b/src/venus/venus-protocol/vn_protocol_renderer.h index 3de37e102..7e14637f0 100644 --- a/src/venus/venus-protocol/vn_protocol_renderer.h +++ b/src/venus/venus-protocol/vn_protocol_renderer.h @@ -1,4 +1,4 @@ -/* This file is generated by venus-protocol git-2f119241. */ +/* This file is generated by venus-protocol git-41236da2. */ /* * Copyright 2020 Google LLC @@ -13,6 +13,7 @@ #include "vn_protocol_renderer_info.h" #include "vn_protocol_renderer_types.h" #include "vn_protocol_renderer_handles.h" +#include "vn_protocol_renderer_util.h" #include "vn_protocol_renderer_dispatches.h" #include "vn_protocol_renderer_structs.h" #include "vn_protocol_renderer_transport.h" diff --git a/src/venus/venus-protocol/vn_protocol_renderer_util.h b/src/venus/venus-protocol/vn_protocol_renderer_util.h new file mode 100644 index 000000000..76e0e0871 --- /dev/null +++ b/src/venus/venus-protocol/vn_protocol_renderer_util.h @@ -0,0 +1,663 @@ +/* This file is generated by venus-protocol. See vn_protocol_renderer.h. */ + +/* + * Copyright 2022 Google LLC + * Copyright 2022 Collabora Ltd. + * SPDX-License-Identifier: MIT + */ + +#ifndef VN_PROTOCOL_RENDERER_UTIL_H +#define VN_PROTOCOL_RENDERER_UTIL_H + +#include "vn_protocol_renderer_info.h" + +struct vn_physical_device_proc_table { + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT GetPhysicalDeviceCalibrateableTimeDomainsEXT; + PFN_vkGetPhysicalDeviceToolProperties GetPhysicalDeviceToolProperties; +}; + +struct vn_device_proc_table { + PFN_vkAllocateCommandBuffers AllocateCommandBuffers; + PFN_vkAllocateDescriptorSets AllocateDescriptorSets; + PFN_vkAllocateMemory AllocateMemory; + PFN_vkBeginCommandBuffer BeginCommandBuffer; + PFN_vkBindBufferMemory BindBufferMemory; + PFN_vkBindBufferMemory2 BindBufferMemory2; + PFN_vkBindImageMemory BindImageMemory; + PFN_vkBindImageMemory2 BindImageMemory2; + PFN_vkCmdBeginQuery CmdBeginQuery; + PFN_vkCmdBeginQueryIndexedEXT CmdBeginQueryIndexedEXT; + PFN_vkCmdBeginRenderPass CmdBeginRenderPass; + PFN_vkCmdBeginRenderPass2 CmdBeginRenderPass2; + PFN_vkCmdBeginRendering CmdBeginRendering; + PFN_vkCmdBeginTransformFeedbackEXT CmdBeginTransformFeedbackEXT; + PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets; + PFN_vkCmdBindIndexBuffer CmdBindIndexBuffer; + PFN_vkCmdBindPipeline CmdBindPipeline; + PFN_vkCmdBindTransformFeedbackBuffersEXT CmdBindTransformFeedbackBuffersEXT; + PFN_vkCmdBindVertexBuffers CmdBindVertexBuffers; + PFN_vkCmdBindVertexBuffers2 CmdBindVertexBuffers2; + PFN_vkCmdBlitImage CmdBlitImage; + PFN_vkCmdBlitImage2 CmdBlitImage2; + PFN_vkCmdClearAttachments CmdClearAttachments; + PFN_vkCmdClearColorImage CmdClearColorImage; + PFN_vkCmdClearDepthStencilImage CmdClearDepthStencilImage; + PFN_vkCmdCopyBuffer CmdCopyBuffer; + PFN_vkCmdCopyBuffer2 CmdCopyBuffer2; + PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage; + PFN_vkCmdCopyBufferToImage2 CmdCopyBufferToImage2; + PFN_vkCmdCopyImage CmdCopyImage; + PFN_vkCmdCopyImage2 CmdCopyImage2; + PFN_vkCmdCopyImageToBuffer CmdCopyImageToBuffer; + PFN_vkCmdCopyImageToBuffer2 CmdCopyImageToBuffer2; + PFN_vkCmdCopyQueryPoolResults CmdCopyQueryPoolResults; + PFN_vkCmdDispatch CmdDispatch; + PFN_vkCmdDispatchBase CmdDispatchBase; + PFN_vkCmdDispatchIndirect CmdDispatchIndirect; + PFN_vkCmdDraw CmdDraw; + PFN_vkCmdDrawIndexed CmdDrawIndexed; + PFN_vkCmdDrawIndexedIndirect CmdDrawIndexedIndirect; + PFN_vkCmdDrawIndexedIndirectCount CmdDrawIndexedIndirectCount; + PFN_vkCmdDrawIndirect CmdDrawIndirect; + PFN_vkCmdDrawIndirectByteCountEXT CmdDrawIndirectByteCountEXT; + PFN_vkCmdDrawIndirectCount CmdDrawIndirectCount; + PFN_vkCmdEndQuery CmdEndQuery; + PFN_vkCmdEndQueryIndexedEXT CmdEndQueryIndexedEXT; + PFN_vkCmdEndRenderPass CmdEndRenderPass; + PFN_vkCmdEndRenderPass2 CmdEndRenderPass2; + PFN_vkCmdEndRendering CmdEndRendering; + PFN_vkCmdEndTransformFeedbackEXT CmdEndTransformFeedbackEXT; + PFN_vkCmdExecuteCommands CmdExecuteCommands; + PFN_vkCmdFillBuffer CmdFillBuffer; + PFN_vkCmdNextSubpass CmdNextSubpass; + PFN_vkCmdNextSubpass2 CmdNextSubpass2; + PFN_vkCmdPipelineBarrier CmdPipelineBarrier; + PFN_vkCmdPipelineBarrier2 CmdPipelineBarrier2; + PFN_vkCmdPushConstants CmdPushConstants; + PFN_vkCmdResetEvent CmdResetEvent; + PFN_vkCmdResetEvent2 CmdResetEvent2; + PFN_vkCmdResetQueryPool CmdResetQueryPool; + PFN_vkCmdResolveImage CmdResolveImage; + PFN_vkCmdResolveImage2 CmdResolveImage2; + PFN_vkCmdSetBlendConstants CmdSetBlendConstants; + PFN_vkCmdSetCullMode CmdSetCullMode; + PFN_vkCmdSetDepthBias CmdSetDepthBias; + PFN_vkCmdSetDepthBiasEnable CmdSetDepthBiasEnable; + PFN_vkCmdSetDepthBounds CmdSetDepthBounds; + PFN_vkCmdSetDepthBoundsTestEnable CmdSetDepthBoundsTestEnable; + PFN_vkCmdSetDepthCompareOp CmdSetDepthCompareOp; + PFN_vkCmdSetDepthTestEnable CmdSetDepthTestEnable; + PFN_vkCmdSetDepthWriteEnable CmdSetDepthWriteEnable; + PFN_vkCmdSetDeviceMask CmdSetDeviceMask; + PFN_vkCmdSetEvent CmdSetEvent; + PFN_vkCmdSetEvent2 CmdSetEvent2; + PFN_vkCmdSetFrontFace CmdSetFrontFace; + PFN_vkCmdSetLineStippleEXT CmdSetLineStippleEXT; + PFN_vkCmdSetLineWidth CmdSetLineWidth; + PFN_vkCmdSetLogicOpEXT CmdSetLogicOpEXT; + PFN_vkCmdSetPatchControlPointsEXT CmdSetPatchControlPointsEXT; + PFN_vkCmdSetPrimitiveRestartEnable CmdSetPrimitiveRestartEnable; + PFN_vkCmdSetPrimitiveTopology CmdSetPrimitiveTopology; + PFN_vkCmdSetRasterizerDiscardEnable CmdSetRasterizerDiscardEnable; + PFN_vkCmdSetScissor CmdSetScissor; + PFN_vkCmdSetScissorWithCount CmdSetScissorWithCount; + PFN_vkCmdSetStencilCompareMask CmdSetStencilCompareMask; + PFN_vkCmdSetStencilOp CmdSetStencilOp; + PFN_vkCmdSetStencilReference CmdSetStencilReference; + PFN_vkCmdSetStencilTestEnable CmdSetStencilTestEnable; + PFN_vkCmdSetStencilWriteMask CmdSetStencilWriteMask; + PFN_vkCmdSetViewport CmdSetViewport; + PFN_vkCmdSetViewportWithCount CmdSetViewportWithCount; + PFN_vkCmdUpdateBuffer CmdUpdateBuffer; + PFN_vkCmdWaitEvents CmdWaitEvents; + PFN_vkCmdWaitEvents2 CmdWaitEvents2; + PFN_vkCmdWriteTimestamp CmdWriteTimestamp; + PFN_vkCmdWriteTimestamp2 CmdWriteTimestamp2; + PFN_vkCreateBuffer CreateBuffer; + PFN_vkCreateBufferView CreateBufferView; + PFN_vkCreateCommandPool CreateCommandPool; + PFN_vkCreateComputePipelines CreateComputePipelines; + PFN_vkCreateDescriptorPool CreateDescriptorPool; + PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout; + PFN_vkCreateDescriptorUpdateTemplate CreateDescriptorUpdateTemplate; + PFN_vkCreateEvent CreateEvent; + PFN_vkCreateFence CreateFence; + PFN_vkCreateFramebuffer CreateFramebuffer; + PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines; + PFN_vkCreateImage CreateImage; + PFN_vkCreateImageView CreateImageView; + PFN_vkCreatePipelineCache CreatePipelineCache; + PFN_vkCreatePipelineLayout CreatePipelineLayout; + PFN_vkCreatePrivateDataSlot CreatePrivateDataSlot; + PFN_vkCreateQueryPool CreateQueryPool; + PFN_vkCreateRenderPass CreateRenderPass; + PFN_vkCreateRenderPass2 CreateRenderPass2; + PFN_vkCreateSampler CreateSampler; + PFN_vkCreateSamplerYcbcrConversion CreateSamplerYcbcrConversion; + PFN_vkCreateSemaphore CreateSemaphore; + PFN_vkCreateShaderModule CreateShaderModule; + PFN_vkDestroyBuffer DestroyBuffer; + PFN_vkDestroyBufferView DestroyBufferView; + PFN_vkDestroyCommandPool DestroyCommandPool; + PFN_vkDestroyDescriptorPool DestroyDescriptorPool; + PFN_vkDestroyDescriptorSetLayout DestroyDescriptorSetLayout; + PFN_vkDestroyDescriptorUpdateTemplate DestroyDescriptorUpdateTemplate; + PFN_vkDestroyDevice DestroyDevice; + PFN_vkDestroyEvent DestroyEvent; + PFN_vkDestroyFence DestroyFence; + PFN_vkDestroyFramebuffer DestroyFramebuffer; + PFN_vkDestroyImage DestroyImage; + PFN_vkDestroyImageView DestroyImageView; + PFN_vkDestroyPipeline DestroyPipeline; + PFN_vkDestroyPipelineCache DestroyPipelineCache; + PFN_vkDestroyPipelineLayout DestroyPipelineLayout; + PFN_vkDestroyPrivateDataSlot DestroyPrivateDataSlot; + PFN_vkDestroyQueryPool DestroyQueryPool; + PFN_vkDestroyRenderPass DestroyRenderPass; + PFN_vkDestroySampler DestroySampler; + PFN_vkDestroySamplerYcbcrConversion DestroySamplerYcbcrConversion; + PFN_vkDestroySemaphore DestroySemaphore; + PFN_vkDestroyShaderModule DestroyShaderModule; + PFN_vkDeviceWaitIdle DeviceWaitIdle; + PFN_vkEndCommandBuffer EndCommandBuffer; + PFN_vkFlushMappedMemoryRanges FlushMappedMemoryRanges; + PFN_vkFreeCommandBuffers FreeCommandBuffers; + PFN_vkFreeDescriptorSets FreeDescriptorSets; + PFN_vkFreeMemory FreeMemory; + PFN_vkGetBufferDeviceAddress GetBufferDeviceAddress; + PFN_vkGetBufferMemoryRequirements GetBufferMemoryRequirements; + PFN_vkGetBufferMemoryRequirements2 GetBufferMemoryRequirements2; + PFN_vkGetBufferOpaqueCaptureAddress GetBufferOpaqueCaptureAddress; + PFN_vkGetCalibratedTimestampsEXT GetCalibratedTimestampsEXT; + PFN_vkGetDescriptorSetLayoutSupport GetDescriptorSetLayoutSupport; + PFN_vkGetDeviceBufferMemoryRequirements GetDeviceBufferMemoryRequirements; + PFN_vkGetDeviceGroupPeerMemoryFeatures GetDeviceGroupPeerMemoryFeatures; + PFN_vkGetDeviceImageMemoryRequirements GetDeviceImageMemoryRequirements; + PFN_vkGetDeviceImageSparseMemoryRequirements GetDeviceImageSparseMemoryRequirements; + PFN_vkGetDeviceMemoryCommitment GetDeviceMemoryCommitment; + PFN_vkGetDeviceMemoryOpaqueCaptureAddress GetDeviceMemoryOpaqueCaptureAddress; + PFN_vkGetDeviceProcAddr GetDeviceProcAddr; + PFN_vkGetDeviceQueue GetDeviceQueue; + PFN_vkGetDeviceQueue2 GetDeviceQueue2; + PFN_vkGetEventStatus GetEventStatus; + PFN_vkGetFenceStatus GetFenceStatus; + PFN_vkGetImageDrmFormatModifierPropertiesEXT GetImageDrmFormatModifierPropertiesEXT; + PFN_vkGetImageMemoryRequirements GetImageMemoryRequirements; + PFN_vkGetImageMemoryRequirements2 GetImageMemoryRequirements2; + PFN_vkGetImageSparseMemoryRequirements GetImageSparseMemoryRequirements; + PFN_vkGetImageSparseMemoryRequirements2 GetImageSparseMemoryRequirements2; + PFN_vkGetImageSubresourceLayout GetImageSubresourceLayout; + PFN_vkGetMemoryFdKHR GetMemoryFdKHR; + PFN_vkGetMemoryFdPropertiesKHR GetMemoryFdPropertiesKHR; + PFN_vkGetPipelineCacheData GetPipelineCacheData; + PFN_vkGetPrivateData GetPrivateData; + PFN_vkGetQueryPoolResults GetQueryPoolResults; + PFN_vkGetRenderAreaGranularity GetRenderAreaGranularity; + PFN_vkGetSemaphoreCounterValue GetSemaphoreCounterValue; + PFN_vkInvalidateMappedMemoryRanges InvalidateMappedMemoryRanges; + PFN_vkMapMemory MapMemory; + PFN_vkMergePipelineCaches MergePipelineCaches; + PFN_vkQueueBindSparse QueueBindSparse; + PFN_vkQueueSubmit QueueSubmit; + PFN_vkQueueSubmit2 QueueSubmit2; + PFN_vkQueueWaitIdle QueueWaitIdle; + PFN_vkResetCommandBuffer ResetCommandBuffer; + PFN_vkResetCommandPool ResetCommandPool; + PFN_vkResetDescriptorPool ResetDescriptorPool; + PFN_vkResetEvent ResetEvent; + PFN_vkResetFences ResetFences; + PFN_vkResetQueryPool ResetQueryPool; + PFN_vkSetEvent SetEvent; + PFN_vkSetPrivateData SetPrivateData; + PFN_vkSignalSemaphore SignalSemaphore; + PFN_vkTrimCommandPool TrimCommandPool; + PFN_vkUnmapMemory UnmapMemory; + PFN_vkUpdateDescriptorSetWithTemplate UpdateDescriptorSetWithTemplate; + PFN_vkUpdateDescriptorSets UpdateDescriptorSets; + PFN_vkWaitForFences WaitForFences; + PFN_vkWaitSemaphores WaitSemaphores; +}; + +static inline void +vn_util_init_physical_device_proc_table(VkInstance instance, + struct vn_physical_device_proc_table *proc_table) +{ +#define VN_GIPA(instance, cmd) (PFN_ ## cmd)vkGetInstanceProcAddr(instance, #cmd) + proc_table->GetPhysicalDeviceCalibrateableTimeDomainsEXT = VN_GIPA(instance, vkGetPhysicalDeviceCalibrateableTimeDomainsEXT); + proc_table->GetPhysicalDeviceToolProperties = VN_GIPA(instance, vkGetPhysicalDeviceToolProperties); + if (!proc_table->GetPhysicalDeviceToolProperties) + proc_table->GetPhysicalDeviceToolProperties = VN_GIPA(instance, vkGetPhysicalDeviceToolPropertiesEXT); +#undef VN_GIPA +} + + +static inline void +vn_util_init_device_proc_table(VkDevice dev, + uint32_t api_version, + const struct vn_info_extension_table *ext_table, + struct vn_device_proc_table *proc_table) +{ +#define VN_GDPA(dev, cmd) (PFN_ ## cmd)vkGetDeviceProcAddr(dev, #cmd) + proc_table->AllocateCommandBuffers = VN_GDPA(dev, vkAllocateCommandBuffers); + proc_table->AllocateDescriptorSets = VN_GDPA(dev, vkAllocateDescriptorSets); + proc_table->AllocateMemory = VN_GDPA(dev, vkAllocateMemory); + proc_table->BeginCommandBuffer = VN_GDPA(dev, vkBeginCommandBuffer); + proc_table->BindBufferMemory = VN_GDPA(dev, vkBindBufferMemory); + proc_table->BindBufferMemory2 = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkBindBufferMemory2) : + ext_table->KHR_bind_memory2 ? VN_GDPA(dev, vkBindBufferMemory2KHR) : + NULL; + proc_table->BindImageMemory = VN_GDPA(dev, vkBindImageMemory); + proc_table->BindImageMemory2 = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkBindImageMemory2) : + ext_table->KHR_bind_memory2 ? VN_GDPA(dev, vkBindImageMemory2KHR) : + NULL; + proc_table->CmdBeginQuery = VN_GDPA(dev, vkCmdBeginQuery); + proc_table->CmdBeginQueryIndexedEXT = + ext_table->EXT_transform_feedback ? VN_GDPA(dev, vkCmdBeginQueryIndexedEXT) : + NULL; + proc_table->CmdBeginRenderPass = VN_GDPA(dev, vkCmdBeginRenderPass); + proc_table->CmdBeginRenderPass2 = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkCmdBeginRenderPass2) : + ext_table->KHR_create_renderpass2 ? VN_GDPA(dev, vkCmdBeginRenderPass2KHR) : + NULL; + proc_table->CmdBeginRendering = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdBeginRendering) : + ext_table->KHR_dynamic_rendering ? VN_GDPA(dev, vkCmdBeginRenderingKHR) : + NULL; + proc_table->CmdBeginTransformFeedbackEXT = + ext_table->EXT_transform_feedback ? VN_GDPA(dev, vkCmdBeginTransformFeedbackEXT) : + NULL; + proc_table->CmdBindDescriptorSets = VN_GDPA(dev, vkCmdBindDescriptorSets); + proc_table->CmdBindIndexBuffer = VN_GDPA(dev, vkCmdBindIndexBuffer); + proc_table->CmdBindPipeline = VN_GDPA(dev, vkCmdBindPipeline); + proc_table->CmdBindTransformFeedbackBuffersEXT = + ext_table->EXT_transform_feedback ? VN_GDPA(dev, vkCmdBindTransformFeedbackBuffersEXT) : + NULL; + proc_table->CmdBindVertexBuffers = VN_GDPA(dev, vkCmdBindVertexBuffers); + proc_table->CmdBindVertexBuffers2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdBindVertexBuffers2) : + ext_table->EXT_extended_dynamic_state ? VN_GDPA(dev, vkCmdBindVertexBuffers2EXT) : + NULL; + proc_table->CmdBlitImage = VN_GDPA(dev, vkCmdBlitImage); + proc_table->CmdBlitImage2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdBlitImage2) : + ext_table->KHR_copy_commands2 ? VN_GDPA(dev, vkCmdBlitImage2KHR) : + NULL; + proc_table->CmdClearAttachments = VN_GDPA(dev, vkCmdClearAttachments); + proc_table->CmdClearColorImage = VN_GDPA(dev, vkCmdClearColorImage); + proc_table->CmdClearDepthStencilImage = VN_GDPA(dev, vkCmdClearDepthStencilImage); + proc_table->CmdCopyBuffer = VN_GDPA(dev, vkCmdCopyBuffer); + proc_table->CmdCopyBuffer2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdCopyBuffer2) : + ext_table->KHR_copy_commands2 ? VN_GDPA(dev, vkCmdCopyBuffer2KHR) : + NULL; + proc_table->CmdCopyBufferToImage = VN_GDPA(dev, vkCmdCopyBufferToImage); + proc_table->CmdCopyBufferToImage2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdCopyBufferToImage2) : + ext_table->KHR_copy_commands2 ? VN_GDPA(dev, vkCmdCopyBufferToImage2KHR) : + NULL; + proc_table->CmdCopyImage = VN_GDPA(dev, vkCmdCopyImage); + proc_table->CmdCopyImage2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdCopyImage2) : + ext_table->KHR_copy_commands2 ? VN_GDPA(dev, vkCmdCopyImage2KHR) : + NULL; + proc_table->CmdCopyImageToBuffer = VN_GDPA(dev, vkCmdCopyImageToBuffer); + proc_table->CmdCopyImageToBuffer2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdCopyImageToBuffer2) : + ext_table->KHR_copy_commands2 ? VN_GDPA(dev, vkCmdCopyImageToBuffer2KHR) : + NULL; + proc_table->CmdCopyQueryPoolResults = VN_GDPA(dev, vkCmdCopyQueryPoolResults); + proc_table->CmdDispatch = VN_GDPA(dev, vkCmdDispatch); + proc_table->CmdDispatchBase = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkCmdDispatchBase) : + ext_table->KHR_device_group ? VN_GDPA(dev, vkCmdDispatchBaseKHR) : + NULL; + proc_table->CmdDispatchIndirect = VN_GDPA(dev, vkCmdDispatchIndirect); + proc_table->CmdDraw = VN_GDPA(dev, vkCmdDraw); + proc_table->CmdDrawIndexed = VN_GDPA(dev, vkCmdDrawIndexed); + proc_table->CmdDrawIndexedIndirect = VN_GDPA(dev, vkCmdDrawIndexedIndirect); + proc_table->CmdDrawIndexedIndirectCount = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkCmdDrawIndexedIndirectCount) : + ext_table->KHR_draw_indirect_count ? VN_GDPA(dev, vkCmdDrawIndexedIndirectCountKHR) : + NULL; + proc_table->CmdDrawIndirect = VN_GDPA(dev, vkCmdDrawIndirect); + proc_table->CmdDrawIndirectByteCountEXT = + ext_table->EXT_transform_feedback ? VN_GDPA(dev, vkCmdDrawIndirectByteCountEXT) : + NULL; + proc_table->CmdDrawIndirectCount = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkCmdDrawIndirectCount) : + ext_table->KHR_draw_indirect_count ? VN_GDPA(dev, vkCmdDrawIndirectCountKHR) : + NULL; + proc_table->CmdEndQuery = VN_GDPA(dev, vkCmdEndQuery); + proc_table->CmdEndQueryIndexedEXT = + ext_table->EXT_transform_feedback ? VN_GDPA(dev, vkCmdEndQueryIndexedEXT) : + NULL; + proc_table->CmdEndRenderPass = VN_GDPA(dev, vkCmdEndRenderPass); + proc_table->CmdEndRenderPass2 = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkCmdEndRenderPass2) : + ext_table->KHR_create_renderpass2 ? VN_GDPA(dev, vkCmdEndRenderPass2KHR) : + NULL; + proc_table->CmdEndRendering = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdEndRendering) : + ext_table->KHR_dynamic_rendering ? VN_GDPA(dev, vkCmdEndRenderingKHR) : + NULL; + proc_table->CmdEndTransformFeedbackEXT = + ext_table->EXT_transform_feedback ? VN_GDPA(dev, vkCmdEndTransformFeedbackEXT) : + NULL; + proc_table->CmdExecuteCommands = VN_GDPA(dev, vkCmdExecuteCommands); + proc_table->CmdFillBuffer = VN_GDPA(dev, vkCmdFillBuffer); + proc_table->CmdNextSubpass = VN_GDPA(dev, vkCmdNextSubpass); + proc_table->CmdNextSubpass2 = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkCmdNextSubpass2) : + ext_table->KHR_create_renderpass2 ? VN_GDPA(dev, vkCmdNextSubpass2KHR) : + NULL; + proc_table->CmdPipelineBarrier = VN_GDPA(dev, vkCmdPipelineBarrier); + proc_table->CmdPipelineBarrier2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdPipelineBarrier2) : + ext_table->KHR_synchronization2 ? VN_GDPA(dev, vkCmdPipelineBarrier2KHR) : + NULL; + proc_table->CmdPushConstants = VN_GDPA(dev, vkCmdPushConstants); + proc_table->CmdResetEvent = VN_GDPA(dev, vkCmdResetEvent); + proc_table->CmdResetEvent2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdResetEvent2) : + ext_table->KHR_synchronization2 ? VN_GDPA(dev, vkCmdResetEvent2KHR) : + NULL; + proc_table->CmdResetQueryPool = VN_GDPA(dev, vkCmdResetQueryPool); + proc_table->CmdResolveImage = VN_GDPA(dev, vkCmdResolveImage); + proc_table->CmdResolveImage2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdResolveImage2) : + ext_table->KHR_copy_commands2 ? VN_GDPA(dev, vkCmdResolveImage2KHR) : + NULL; + proc_table->CmdSetBlendConstants = VN_GDPA(dev, vkCmdSetBlendConstants); + proc_table->CmdSetCullMode = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetCullMode) : + ext_table->EXT_extended_dynamic_state ? VN_GDPA(dev, vkCmdSetCullModeEXT) : + NULL; + proc_table->CmdSetDepthBias = VN_GDPA(dev, vkCmdSetDepthBias); + proc_table->CmdSetDepthBiasEnable = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetDepthBiasEnable) : + ext_table->EXT_extended_dynamic_state2 ? VN_GDPA(dev, vkCmdSetDepthBiasEnableEXT) : + NULL; + proc_table->CmdSetDepthBounds = VN_GDPA(dev, vkCmdSetDepthBounds); + proc_table->CmdSetDepthBoundsTestEnable = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetDepthBoundsTestEnable) : + ext_table->EXT_extended_dynamic_state ? VN_GDPA(dev, vkCmdSetDepthBoundsTestEnableEXT) : + NULL; + proc_table->CmdSetDepthCompareOp = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetDepthCompareOp) : + ext_table->EXT_extended_dynamic_state ? VN_GDPA(dev, vkCmdSetDepthCompareOpEXT) : + NULL; + proc_table->CmdSetDepthTestEnable = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetDepthTestEnable) : + ext_table->EXT_extended_dynamic_state ? VN_GDPA(dev, vkCmdSetDepthTestEnableEXT) : + NULL; + proc_table->CmdSetDepthWriteEnable = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetDepthWriteEnable) : + ext_table->EXT_extended_dynamic_state ? VN_GDPA(dev, vkCmdSetDepthWriteEnableEXT) : + NULL; + proc_table->CmdSetDeviceMask = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkCmdSetDeviceMask) : + ext_table->KHR_device_group ? VN_GDPA(dev, vkCmdSetDeviceMaskKHR) : + NULL; + proc_table->CmdSetEvent = VN_GDPA(dev, vkCmdSetEvent); + proc_table->CmdSetEvent2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetEvent2) : + ext_table->KHR_synchronization2 ? VN_GDPA(dev, vkCmdSetEvent2KHR) : + NULL; + proc_table->CmdSetFrontFace = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetFrontFace) : + ext_table->EXT_extended_dynamic_state ? VN_GDPA(dev, vkCmdSetFrontFaceEXT) : + NULL; + proc_table->CmdSetLineStippleEXT = + ext_table->EXT_line_rasterization ? VN_GDPA(dev, vkCmdSetLineStippleEXT) : + NULL; + proc_table->CmdSetLineWidth = VN_GDPA(dev, vkCmdSetLineWidth); + proc_table->CmdSetLogicOpEXT = + ext_table->EXT_extended_dynamic_state2 ? VN_GDPA(dev, vkCmdSetLogicOpEXT) : + NULL; + proc_table->CmdSetPatchControlPointsEXT = + ext_table->EXT_extended_dynamic_state2 ? VN_GDPA(dev, vkCmdSetPatchControlPointsEXT) : + NULL; + proc_table->CmdSetPrimitiveRestartEnable = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetPrimitiveRestartEnable) : + ext_table->EXT_extended_dynamic_state2 ? VN_GDPA(dev, vkCmdSetPrimitiveRestartEnableEXT) : + NULL; + proc_table->CmdSetPrimitiveTopology = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetPrimitiveTopology) : + ext_table->EXT_extended_dynamic_state ? VN_GDPA(dev, vkCmdSetPrimitiveTopologyEXT) : + NULL; + proc_table->CmdSetRasterizerDiscardEnable = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetRasterizerDiscardEnable) : + ext_table->EXT_extended_dynamic_state2 ? VN_GDPA(dev, vkCmdSetRasterizerDiscardEnableEXT) : + NULL; + proc_table->CmdSetScissor = VN_GDPA(dev, vkCmdSetScissor); + proc_table->CmdSetScissorWithCount = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetScissorWithCount) : + ext_table->EXT_extended_dynamic_state ? VN_GDPA(dev, vkCmdSetScissorWithCountEXT) : + NULL; + proc_table->CmdSetStencilCompareMask = VN_GDPA(dev, vkCmdSetStencilCompareMask); + proc_table->CmdSetStencilOp = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetStencilOp) : + ext_table->EXT_extended_dynamic_state ? VN_GDPA(dev, vkCmdSetStencilOpEXT) : + NULL; + proc_table->CmdSetStencilReference = VN_GDPA(dev, vkCmdSetStencilReference); + proc_table->CmdSetStencilTestEnable = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetStencilTestEnable) : + ext_table->EXT_extended_dynamic_state ? VN_GDPA(dev, vkCmdSetStencilTestEnableEXT) : + NULL; + proc_table->CmdSetStencilWriteMask = VN_GDPA(dev, vkCmdSetStencilWriteMask); + proc_table->CmdSetViewport = VN_GDPA(dev, vkCmdSetViewport); + proc_table->CmdSetViewportWithCount = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdSetViewportWithCount) : + ext_table->EXT_extended_dynamic_state ? VN_GDPA(dev, vkCmdSetViewportWithCountEXT) : + NULL; + proc_table->CmdUpdateBuffer = VN_GDPA(dev, vkCmdUpdateBuffer); + proc_table->CmdWaitEvents = VN_GDPA(dev, vkCmdWaitEvents); + proc_table->CmdWaitEvents2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdWaitEvents2) : + ext_table->KHR_synchronization2 ? VN_GDPA(dev, vkCmdWaitEvents2KHR) : + NULL; + proc_table->CmdWriteTimestamp = VN_GDPA(dev, vkCmdWriteTimestamp); + proc_table->CmdWriteTimestamp2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCmdWriteTimestamp2) : + ext_table->KHR_synchronization2 ? VN_GDPA(dev, vkCmdWriteTimestamp2KHR) : + NULL; + proc_table->CreateBuffer = VN_GDPA(dev, vkCreateBuffer); + proc_table->CreateBufferView = VN_GDPA(dev, vkCreateBufferView); + proc_table->CreateCommandPool = VN_GDPA(dev, vkCreateCommandPool); + proc_table->CreateComputePipelines = VN_GDPA(dev, vkCreateComputePipelines); + proc_table->CreateDescriptorPool = VN_GDPA(dev, vkCreateDescriptorPool); + proc_table->CreateDescriptorSetLayout = VN_GDPA(dev, vkCreateDescriptorSetLayout); + proc_table->CreateDescriptorUpdateTemplate = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkCreateDescriptorUpdateTemplate) : + ext_table->KHR_descriptor_update_template ? VN_GDPA(dev, vkCreateDescriptorUpdateTemplateKHR) : + NULL; + proc_table->CreateEvent = VN_GDPA(dev, vkCreateEvent); + proc_table->CreateFence = VN_GDPA(dev, vkCreateFence); + proc_table->CreateFramebuffer = VN_GDPA(dev, vkCreateFramebuffer); + proc_table->CreateGraphicsPipelines = VN_GDPA(dev, vkCreateGraphicsPipelines); + proc_table->CreateImage = VN_GDPA(dev, vkCreateImage); + proc_table->CreateImageView = VN_GDPA(dev, vkCreateImageView); + proc_table->CreatePipelineCache = VN_GDPA(dev, vkCreatePipelineCache); + proc_table->CreatePipelineLayout = VN_GDPA(dev, vkCreatePipelineLayout); + proc_table->CreatePrivateDataSlot = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkCreatePrivateDataSlot) : + ext_table->EXT_private_data ? VN_GDPA(dev, vkCreatePrivateDataSlotEXT) : + NULL; + proc_table->CreateQueryPool = VN_GDPA(dev, vkCreateQueryPool); + proc_table->CreateRenderPass = VN_GDPA(dev, vkCreateRenderPass); + proc_table->CreateRenderPass2 = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkCreateRenderPass2) : + ext_table->KHR_create_renderpass2 ? VN_GDPA(dev, vkCreateRenderPass2KHR) : + NULL; + proc_table->CreateSampler = VN_GDPA(dev, vkCreateSampler); + proc_table->CreateSamplerYcbcrConversion = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkCreateSamplerYcbcrConversion) : + ext_table->KHR_sampler_ycbcr_conversion ? VN_GDPA(dev, vkCreateSamplerYcbcrConversionKHR) : + NULL; + proc_table->CreateSemaphore = VN_GDPA(dev, vkCreateSemaphore); + proc_table->CreateShaderModule = VN_GDPA(dev, vkCreateShaderModule); + proc_table->DestroyBuffer = VN_GDPA(dev, vkDestroyBuffer); + proc_table->DestroyBufferView = VN_GDPA(dev, vkDestroyBufferView); + proc_table->DestroyCommandPool = VN_GDPA(dev, vkDestroyCommandPool); + proc_table->DestroyDescriptorPool = VN_GDPA(dev, vkDestroyDescriptorPool); + proc_table->DestroyDescriptorSetLayout = VN_GDPA(dev, vkDestroyDescriptorSetLayout); + proc_table->DestroyDescriptorUpdateTemplate = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkDestroyDescriptorUpdateTemplate) : + ext_table->KHR_descriptor_update_template ? VN_GDPA(dev, vkDestroyDescriptorUpdateTemplateKHR) : + NULL; + proc_table->DestroyDevice = VN_GDPA(dev, vkDestroyDevice); + proc_table->DestroyEvent = VN_GDPA(dev, vkDestroyEvent); + proc_table->DestroyFence = VN_GDPA(dev, vkDestroyFence); + proc_table->DestroyFramebuffer = VN_GDPA(dev, vkDestroyFramebuffer); + proc_table->DestroyImage = VN_GDPA(dev, vkDestroyImage); + proc_table->DestroyImageView = VN_GDPA(dev, vkDestroyImageView); + proc_table->DestroyPipeline = VN_GDPA(dev, vkDestroyPipeline); + proc_table->DestroyPipelineCache = VN_GDPA(dev, vkDestroyPipelineCache); + proc_table->DestroyPipelineLayout = VN_GDPA(dev, vkDestroyPipelineLayout); + proc_table->DestroyPrivateDataSlot = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkDestroyPrivateDataSlot) : + ext_table->EXT_private_data ? VN_GDPA(dev, vkDestroyPrivateDataSlotEXT) : + NULL; + proc_table->DestroyQueryPool = VN_GDPA(dev, vkDestroyQueryPool); + proc_table->DestroyRenderPass = VN_GDPA(dev, vkDestroyRenderPass); + proc_table->DestroySampler = VN_GDPA(dev, vkDestroySampler); + proc_table->DestroySamplerYcbcrConversion = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkDestroySamplerYcbcrConversion) : + ext_table->KHR_sampler_ycbcr_conversion ? VN_GDPA(dev, vkDestroySamplerYcbcrConversionKHR) : + NULL; + proc_table->DestroySemaphore = VN_GDPA(dev, vkDestroySemaphore); + proc_table->DestroyShaderModule = VN_GDPA(dev, vkDestroyShaderModule); + proc_table->DeviceWaitIdle = VN_GDPA(dev, vkDeviceWaitIdle); + proc_table->EndCommandBuffer = VN_GDPA(dev, vkEndCommandBuffer); + proc_table->FlushMappedMemoryRanges = VN_GDPA(dev, vkFlushMappedMemoryRanges); + proc_table->FreeCommandBuffers = VN_GDPA(dev, vkFreeCommandBuffers); + proc_table->FreeDescriptorSets = VN_GDPA(dev, vkFreeDescriptorSets); + proc_table->FreeMemory = VN_GDPA(dev, vkFreeMemory); + proc_table->GetBufferDeviceAddress = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkGetBufferDeviceAddress) : + ext_table->KHR_buffer_device_address ? VN_GDPA(dev, vkGetBufferDeviceAddressKHR) : + NULL; + proc_table->GetBufferMemoryRequirements = VN_GDPA(dev, vkGetBufferMemoryRequirements); + proc_table->GetBufferMemoryRequirements2 = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkGetBufferMemoryRequirements2) : + ext_table->KHR_get_memory_requirements2 ? VN_GDPA(dev, vkGetBufferMemoryRequirements2KHR) : + NULL; + proc_table->GetBufferOpaqueCaptureAddress = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkGetBufferOpaqueCaptureAddress) : + ext_table->KHR_buffer_device_address ? VN_GDPA(dev, vkGetBufferOpaqueCaptureAddressKHR) : + NULL; + proc_table->GetCalibratedTimestampsEXT = + ext_table->EXT_calibrated_timestamps ? VN_GDPA(dev, vkGetCalibratedTimestampsEXT) : + NULL; + proc_table->GetDescriptorSetLayoutSupport = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkGetDescriptorSetLayoutSupport) : + ext_table->KHR_maintenance3 ? VN_GDPA(dev, vkGetDescriptorSetLayoutSupportKHR) : + NULL; + proc_table->GetDeviceBufferMemoryRequirements = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkGetDeviceBufferMemoryRequirements) : + ext_table->KHR_maintenance4 ? VN_GDPA(dev, vkGetDeviceBufferMemoryRequirementsKHR) : + NULL; + proc_table->GetDeviceGroupPeerMemoryFeatures = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkGetDeviceGroupPeerMemoryFeatures) : + ext_table->KHR_device_group ? VN_GDPA(dev, vkGetDeviceGroupPeerMemoryFeaturesKHR) : + NULL; + proc_table->GetDeviceImageMemoryRequirements = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkGetDeviceImageMemoryRequirements) : + ext_table->KHR_maintenance4 ? VN_GDPA(dev, vkGetDeviceImageMemoryRequirementsKHR) : + NULL; + proc_table->GetDeviceImageSparseMemoryRequirements = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkGetDeviceImageSparseMemoryRequirements) : + ext_table->KHR_maintenance4 ? VN_GDPA(dev, vkGetDeviceImageSparseMemoryRequirementsKHR) : + NULL; + proc_table->GetDeviceMemoryCommitment = VN_GDPA(dev, vkGetDeviceMemoryCommitment); + proc_table->GetDeviceMemoryOpaqueCaptureAddress = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkGetDeviceMemoryOpaqueCaptureAddress) : + ext_table->KHR_buffer_device_address ? VN_GDPA(dev, vkGetDeviceMemoryOpaqueCaptureAddressKHR) : + NULL; + proc_table->GetDeviceProcAddr = VN_GDPA(dev, vkGetDeviceProcAddr); + proc_table->GetDeviceQueue = VN_GDPA(dev, vkGetDeviceQueue); + proc_table->GetDeviceQueue2 = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkGetDeviceQueue2) : + NULL; + proc_table->GetEventStatus = VN_GDPA(dev, vkGetEventStatus); + proc_table->GetFenceStatus = VN_GDPA(dev, vkGetFenceStatus); + proc_table->GetImageDrmFormatModifierPropertiesEXT = + ext_table->EXT_image_drm_format_modifier ? VN_GDPA(dev, vkGetImageDrmFormatModifierPropertiesEXT) : + NULL; + proc_table->GetImageMemoryRequirements = VN_GDPA(dev, vkGetImageMemoryRequirements); + proc_table->GetImageMemoryRequirements2 = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkGetImageMemoryRequirements2) : + ext_table->KHR_get_memory_requirements2 ? VN_GDPA(dev, vkGetImageMemoryRequirements2KHR) : + NULL; + proc_table->GetImageSparseMemoryRequirements = VN_GDPA(dev, vkGetImageSparseMemoryRequirements); + proc_table->GetImageSparseMemoryRequirements2 = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkGetImageSparseMemoryRequirements2) : + ext_table->KHR_get_memory_requirements2 ? VN_GDPA(dev, vkGetImageSparseMemoryRequirements2KHR) : + NULL; + proc_table->GetImageSubresourceLayout = VN_GDPA(dev, vkGetImageSubresourceLayout); + proc_table->GetMemoryFdKHR = + ext_table->KHR_external_memory_fd ? VN_GDPA(dev, vkGetMemoryFdKHR) : + NULL; + proc_table->GetMemoryFdPropertiesKHR = + ext_table->KHR_external_memory_fd ? VN_GDPA(dev, vkGetMemoryFdPropertiesKHR) : + NULL; + proc_table->GetPipelineCacheData = VN_GDPA(dev, vkGetPipelineCacheData); + proc_table->GetPrivateData = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkGetPrivateData) : + ext_table->EXT_private_data ? VN_GDPA(dev, vkGetPrivateDataEXT) : + NULL; + proc_table->GetQueryPoolResults = VN_GDPA(dev, vkGetQueryPoolResults); + proc_table->GetRenderAreaGranularity = VN_GDPA(dev, vkGetRenderAreaGranularity); + proc_table->GetSemaphoreCounterValue = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkGetSemaphoreCounterValue) : + ext_table->KHR_timeline_semaphore ? VN_GDPA(dev, vkGetSemaphoreCounterValueKHR) : + NULL; + proc_table->InvalidateMappedMemoryRanges = VN_GDPA(dev, vkInvalidateMappedMemoryRanges); + proc_table->MapMemory = VN_GDPA(dev, vkMapMemory); + proc_table->MergePipelineCaches = VN_GDPA(dev, vkMergePipelineCaches); + proc_table->QueueBindSparse = VN_GDPA(dev, vkQueueBindSparse); + proc_table->QueueSubmit = VN_GDPA(dev, vkQueueSubmit); + proc_table->QueueSubmit2 = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkQueueSubmit2) : + ext_table->KHR_synchronization2 ? VN_GDPA(dev, vkQueueSubmit2KHR) : + NULL; + proc_table->QueueWaitIdle = VN_GDPA(dev, vkQueueWaitIdle); + proc_table->ResetCommandBuffer = VN_GDPA(dev, vkResetCommandBuffer); + proc_table->ResetCommandPool = VN_GDPA(dev, vkResetCommandPool); + proc_table->ResetDescriptorPool = VN_GDPA(dev, vkResetDescriptorPool); + proc_table->ResetEvent = VN_GDPA(dev, vkResetEvent); + proc_table->ResetFences = VN_GDPA(dev, vkResetFences); + proc_table->ResetQueryPool = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkResetQueryPool) : + ext_table->EXT_host_query_reset ? VN_GDPA(dev, vkResetQueryPoolEXT) : + NULL; + proc_table->SetEvent = VN_GDPA(dev, vkSetEvent); + proc_table->SetPrivateData = + api_version >= VK_API_VERSION_1_3 ? VN_GDPA(dev, vkSetPrivateData) : + ext_table->EXT_private_data ? VN_GDPA(dev, vkSetPrivateDataEXT) : + NULL; + proc_table->SignalSemaphore = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkSignalSemaphore) : + ext_table->KHR_timeline_semaphore ? VN_GDPA(dev, vkSignalSemaphoreKHR) : + NULL; + proc_table->TrimCommandPool = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkTrimCommandPool) : + ext_table->KHR_maintenance1 ? VN_GDPA(dev, vkTrimCommandPoolKHR) : + NULL; + proc_table->UnmapMemory = VN_GDPA(dev, vkUnmapMemory); + proc_table->UpdateDescriptorSetWithTemplate = + api_version >= VK_API_VERSION_1_1 ? VN_GDPA(dev, vkUpdateDescriptorSetWithTemplate) : + ext_table->KHR_descriptor_update_template ? VN_GDPA(dev, vkUpdateDescriptorSetWithTemplateKHR) : + NULL; + proc_table->UpdateDescriptorSets = VN_GDPA(dev, vkUpdateDescriptorSets); + proc_table->WaitForFences = VN_GDPA(dev, vkWaitForFences); + proc_table->WaitSemaphores = + api_version >= VK_API_VERSION_1_2 ? VN_GDPA(dev, vkWaitSemaphores) : + ext_table->KHR_timeline_semaphore ? VN_GDPA(dev, vkWaitSemaphoresKHR) : + NULL; +#undef VN_GDPA +} + +#endif /* VN_PROTOCOL_RENDERER_UTIL_H */ -- GitLab From d66378dbb47287f457d1e1a17d781ac7187f8f3d Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Mon, 28 Feb 2022 10:36:31 -0300 Subject: [PATCH 2/5] vkr: init proc tables Adds the code to make use of the new proc table functions in the [physical_]device initialization. Co-authored-by: Igor Torrente Co-authored-by: Chia-I Wu Part-of: --- src/venus/vkr_common.c | 13 +++++++++++++ src/venus/vkr_common.h | 6 ++++++ src/venus/vkr_device.c | 19 +++++++++++++++++-- src/venus/vkr_device.h | 5 ++++- src/venus/vkr_physical_device.c | 9 +++++++++ src/venus/vkr_physical_device.h | 4 ++++ 6 files changed, 53 insertions(+), 3 deletions(-) diff --git a/src/venus/vkr_common.c b/src/venus/vkr_common.c index 5e9d8e8b5..6a3e5ba03 100644 --- a/src/venus/vkr_common.c +++ b/src/venus/vkr_common.c @@ -143,6 +143,19 @@ vkr_log(const char *fmt, ...) virgl_log(line); } +void +vkr_extension_table_init(struct vn_info_extension_table *table, + const char *const *exts, + uint32_t count) +{ + memset(table, 0, sizeof(*table)); + for (uint32_t i = 0; i < count; i++) { + const struct vn_info_extension *ext = vn_info_extension_get(exts[i]); + if (ext) + table->enabled[ext->index] = true; + } +} + uint32_t vkr_extension_get_spec_version(const char *name) { diff --git a/src/venus/vkr_common.h b/src/venus/vkr_common.h index 0311e5040..e1c9ce5a4 100644 --- a/src/venus/vkr_common.h +++ b/src/venus/vkr_common.h @@ -59,6 +59,7 @@ .begin = (offset), .end = (offset) + (size) \ } +struct vn_info_extension_table; struct vkr_context; struct vkr_instance; struct vkr_physical_device; @@ -166,6 +167,11 @@ vkr_api_version_cap_minor(uint32_t version, uint32_t cap) return version; } +void +vkr_extension_table_init(struct vn_info_extension_table *table, + const char *const *exts, + uint32_t count); + uint32_t vkr_extension_get_spec_version(const char *name); diff --git a/src/venus/vkr_device.c b/src/venus/vkr_device.c index d2b7e26fe..abbcfafde 100644 --- a/src/venus/vkr_device.c +++ b/src/venus/vkr_device.c @@ -219,6 +219,19 @@ vkr_device_init_entry_points(struct vkr_device *dev, uint32_t api_version) handle, "vkGetMemoryFdPropertiesKHR"); } +static void +vkr_device_init_proc_table(struct vkr_device *dev, + uint32_t api_version, + const char *const *exts, + uint32_t count) +{ + struct vn_info_extension_table ext_table; + vkr_extension_table_init(&ext_table, exts, count); + + vn_util_init_device_proc_table(dev->base.handle.device, api_version, &ext_table, + &dev->proc_table); +} + static void vkr_dispatch_vkCreateDevice(struct vn_dispatch_context *dispatch, struct vn_command_vkCreateDevice *args) @@ -272,10 +285,12 @@ vkr_dispatch_vkCreateDevice(struct vn_dispatch_context *dispatch, return; } - free(exts); - dev->physical_device = physical_dev; + vkr_device_init_proc_table(dev, physical_dev->api_version, exts, ext_count); + + free(exts); + args->ret = vkr_device_create_queues(ctx, dev, args->pCreateInfo->queueCreateInfoCount, args->pCreateInfo->pQueueCreateInfos); if (args->ret != VK_SUCCESS) { diff --git a/src/venus/vkr_device.h b/src/venus/vkr_device.h index 29cca3410..1c510d74a 100644 --- a/src/venus/vkr_device.h +++ b/src/venus/vkr_device.h @@ -6,8 +6,9 @@ #ifndef VKR_DEVICE_H #define VKR_DEVICE_H -#include "vkr_common.h" +#include "venus-protocol/vn_protocol_renderer_util.h" +#include "vkr_common.h" #include "vkr_context.h" struct vkr_device { @@ -15,6 +16,8 @@ struct vkr_device { struct vkr_physical_device *physical_device; + struct vn_device_proc_table proc_table; + /* Vulkan 1.2 */ PFN_vkGetSemaphoreCounterValue GetSemaphoreCounterValue; PFN_vkWaitSemaphores WaitSemaphores; diff --git a/src/venus/vkr_physical_device.c b/src/venus/vkr_physical_device.c index 95cf70651..d98a9b88e 100644 --- a/src/venus/vkr_physical_device.c +++ b/src/venus/vkr_physical_device.c @@ -224,6 +224,14 @@ vkr_physical_device_init_properties(struct vkr_physical_device *physical_dev) /* TODO lie about props->pipelineCacheUUID and patch cache header */ } +static void +vkr_physical_device_init_proc_table(struct vkr_physical_device *physical_dev, + struct vkr_instance *instance) +{ + vn_util_init_physical_device_proc_table(instance->base.handle.instance, + &physical_dev->proc_table); +} + static void vkr_dispatch_vkEnumeratePhysicalDevices(struct vn_dispatch_context *dispatch, struct vn_command_vkEnumeratePhysicalDevices *args) @@ -281,6 +289,7 @@ vkr_dispatch_vkEnumeratePhysicalDevices(struct vn_dispatch_context *dispatch, physical_dev->base.handle.physical_device = instance->physical_device_handles[i]; + vkr_physical_device_init_proc_table(physical_dev, instance); vkr_physical_device_init_properties(physical_dev); physical_dev->api_version = MIN2(physical_dev->properties.apiVersion, instance->api_version); diff --git a/src/venus/vkr_physical_device.h b/src/venus/vkr_physical_device.h index 73e5e4025..d3cfe299c 100644 --- a/src/venus/vkr_physical_device.h +++ b/src/venus/vkr_physical_device.h @@ -8,11 +8,15 @@ #include "vkr_common.h" +#include "venus-protocol/vn_protocol_renderer_util.h" + struct gbm_device; struct vkr_physical_device { struct vkr_object base; + struct vn_physical_device_proc_table proc_table; + VkPhysicalDeviceProperties properties; uint32_t api_version; -- GitLab From 805bfda52c7e759c7e6870cf3ba251942569b369 Mon Sep 17 00:00:00 2001 From: Chia-I Wu Date: Fri, 4 Mar 2022 08:25:10 -0300 Subject: [PATCH 3/5] vkr: remove vkr_device_init_entry_points Removes the old method and update all the affected functions. Co-authored-by: Igor Torrente Co-authored-by: Chia-I Wu Part-of: --- src/venus/vkr_buffer.c | 6 +- src/venus/vkr_command_buffer.c | 90 +++++++++++-------- src/venus/vkr_device.c | 160 --------------------------------- src/venus/vkr_device.h | 44 --------- src/venus/vkr_device_memory.c | 10 ++- src/venus/vkr_image.c | 5 +- src/venus/vkr_query_pool.c | 3 +- src/venus/vkr_queue.c | 9 +- src/venus/vkr_render_pass.c | 5 +- 9 files changed, 77 insertions(+), 255 deletions(-) diff --git a/src/venus/vkr_buffer.c b/src/venus/vkr_buffer.c index 3e3fcb516..bdc239187 100644 --- a/src/venus/vkr_buffer.c +++ b/src/venus/vkr_buffer.c @@ -88,9 +88,10 @@ vkr_dispatch_vkGetBufferOpaqueCaptureAddress( struct vn_command_vkGetBufferOpaqueCaptureAddress *args) { struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; vn_replace_vkGetBufferOpaqueCaptureAddress_args_handle(args); - args->ret = dev->GetBufferOpaqueCaptureAddress(args->device, args->pInfo); + args->ret = vk->GetBufferOpaqueCaptureAddress(args->device, args->pInfo); } static void @@ -98,9 +99,10 @@ vkr_dispatch_vkGetBufferDeviceAddress(UNUSED struct vn_dispatch_context *dispatc struct vn_command_vkGetBufferDeviceAddress *args) { struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; vn_replace_vkGetBufferDeviceAddress_args_handle(args); - args->ret = dev->GetBufferDeviceAddress(args->device, args->pInfo); + args->ret = vk->GetBufferDeviceAddress(args->device, args->pInfo); } static void diff --git a/src/venus/vkr_command_buffer.c b/src/venus/vkr_command_buffer.c index f208882c8..6d9e964ae 100644 --- a/src/venus/vkr_command_buffer.c +++ b/src/venus/vkr_command_buffer.c @@ -526,10 +526,11 @@ vkr_dispatch_vkCmdBeginRenderPass2(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdBeginRenderPass2 *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdBeginRenderPass2_args_handle(args); - cmd->device->CmdBeginRenderPass2(args->commandBuffer, args->pRenderPassBegin, - args->pSubpassBeginInfo); + vk->CmdBeginRenderPass2(args->commandBuffer, args->pRenderPassBegin, + args->pSubpassBeginInfo); } static void @@ -537,10 +538,11 @@ vkr_dispatch_vkCmdNextSubpass2(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdNextSubpass2 *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdNextSubpass2_args_handle(args); - cmd->device->CmdNextSubpass2(args->commandBuffer, args->pSubpassBeginInfo, - args->pSubpassEndInfo); + vk->CmdNextSubpass2(args->commandBuffer, args->pSubpassBeginInfo, + args->pSubpassEndInfo); } static void @@ -548,9 +550,10 @@ vkr_dispatch_vkCmdEndRenderPass2(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdEndRenderPass2 *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdEndRenderPass2_args_handle(args); - cmd->device->CmdEndRenderPass2(args->commandBuffer, args->pSubpassEndInfo); + vk->CmdEndRenderPass2(args->commandBuffer, args->pSubpassEndInfo); } static void @@ -558,11 +561,12 @@ vkr_dispatch_vkCmdDrawIndirectCount(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdDrawIndirectCount *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdDrawIndirectCount_args_handle(args); - cmd->device->CmdDrawIndirectCount(args->commandBuffer, args->buffer, args->offset, - args->countBuffer, args->countBufferOffset, - args->maxDrawCount, args->stride); + vk->CmdDrawIndirectCount(args->commandBuffer, args->buffer, args->offset, + args->countBuffer, args->countBufferOffset, + args->maxDrawCount, args->stride); } static void @@ -573,7 +577,7 @@ vkr_dispatch_vkCmdDrawIndexedIndirectCount( struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); vn_replace_vkCmdDrawIndexedIndirectCount_args_handle(args); - cmd->device->CmdDrawIndexedIndirectCount( + cmd->device->proc_table.CmdDrawIndexedIndirectCount( args->commandBuffer, args->buffer, args->offset, args->countBuffer, args->countBufferOffset, args->maxDrawCount, args->stride); } @@ -583,10 +587,11 @@ vkr_dispatch_vkCmdSetLineStippleEXT(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetLineStippleEXT *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdSetLineStippleEXT_args_handle(args); - cmd->device->cmd_set_line_stipple(args->commandBuffer, args->lineStippleFactor, - args->lineStipplePattern); + vk->CmdSetLineStippleEXT(args->commandBuffer, args->lineStippleFactor, + args->lineStipplePattern); } static void @@ -597,7 +602,7 @@ vkr_dispatch_vkCmdBindTransformFeedbackBuffersEXT( struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); vn_replace_vkCmdBindTransformFeedbackBuffersEXT_args_handle(args); - cmd->device->cmd_bind_transform_feedback_buffers( + cmd->device->proc_table.CmdBindTransformFeedbackBuffersEXT( args->commandBuffer, args->firstBinding, args->bindingCount, args->pBuffers, args->pOffsets, args->pSizes); } @@ -610,7 +615,7 @@ vkr_dispatch_vkCmdBeginTransformFeedbackEXT( struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); vn_replace_vkCmdBeginTransformFeedbackEXT_args_handle(args); - cmd->device->cmd_begin_transform_feedback( + cmd->device->proc_table.CmdBeginTransformFeedbackEXT( args->commandBuffer, args->firstCounterBuffer, args->counterBufferCount, args->pCounterBuffers, args->pCounterBufferOffsets); } @@ -623,7 +628,7 @@ vkr_dispatch_vkCmdEndTransformFeedbackEXT( struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); vn_replace_vkCmdEndTransformFeedbackEXT_args_handle(args); - cmd->device->cmd_end_transform_feedback( + cmd->device->proc_table.CmdEndTransformFeedbackEXT( args->commandBuffer, args->firstCounterBuffer, args->counterBufferCount, args->pCounterBuffers, args->pCounterBufferOffsets); } @@ -633,10 +638,11 @@ vkr_dispatch_vkCmdBeginQueryIndexedEXT(UNUSED struct vn_dispatch_context *dispat struct vn_command_vkCmdBeginQueryIndexedEXT *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdBeginQueryIndexedEXT_args_handle(args); - cmd->device->cmd_begin_query_indexed(args->commandBuffer, args->queryPool, args->query, - args->flags, args->index); + vk->CmdBeginQueryIndexedEXT(args->commandBuffer, args->queryPool, args->query, + args->flags, args->index); } static void @@ -644,10 +650,11 @@ vkr_dispatch_vkCmdEndQueryIndexedEXT(UNUSED struct vn_dispatch_context *dispatch struct vn_command_vkCmdEndQueryIndexedEXT *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdEndQueryIndexedEXT_args_handle(args); - cmd->device->cmd_end_query_indexed(args->commandBuffer, args->queryPool, args->query, - args->index); + vk->CmdEndQueryIndexedEXT(args->commandBuffer, args->queryPool, args->query, + args->index); } static void @@ -658,7 +665,7 @@ vkr_dispatch_vkCmdDrawIndirectByteCountEXT( struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); vn_replace_vkCmdDrawIndirectByteCountEXT_args_handle(args); - cmd->device->cmd_draw_indirect_byte_count( + cmd->device->proc_table.CmdDrawIndirectByteCountEXT( args->commandBuffer, args->instanceCount, args->firstInstance, args->counterBuffer, args->counterBufferOffset, args->counterOffset, args->vertexStride); } @@ -668,11 +675,12 @@ vkr_dispatch_vkCmdBindVertexBuffers2(UNUSED struct vn_dispatch_context *dispatch struct vn_command_vkCmdBindVertexBuffers2 *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdBindVertexBuffers2_args_handle(args); - cmd->device->cmd_bind_vertex_buffers_2(args->commandBuffer, args->firstBinding, - args->bindingCount, args->pBuffers, - args->pOffsets, args->pSizes, args->pStrides); + vk->CmdBindVertexBuffers2(args->commandBuffer, args->firstBinding, args->bindingCount, + args->pBuffers, args->pOffsets, args->pSizes, + args->pStrides); } static void @@ -682,7 +690,7 @@ vkr_dispatch_vkCmdSetCullMode(UNUSED struct vn_dispatch_context *dispatch, struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); vn_replace_vkCmdSetCullMode_args_handle(args); - cmd->device->cmd_set_cull_mode(args->commandBuffer, args->cullMode); + cmd->device->proc_table.CmdSetCullMode(args->commandBuffer, args->cullMode); } static void @@ -693,8 +701,8 @@ vkr_dispatch_vkCmdSetDepthBoundsTestEnable( struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); vn_replace_vkCmdSetDepthBoundsTestEnable_args_handle(args); - cmd->device->cmd_set_depth_bounds_test_enable(args->commandBuffer, - args->depthBoundsTestEnable); + cmd->device->proc_table.CmdSetDepthBoundsTestEnable(args->commandBuffer, + args->depthBoundsTestEnable); } static void @@ -702,9 +710,10 @@ vkr_dispatch_vkCmdSetDepthCompareOp(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetDepthCompareOp *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdSetDepthCompareOp_args_handle(args); - cmd->device->cmd_set_depth_compare_op(args->commandBuffer, args->depthCompareOp); + vk->CmdSetDepthCompareOp(args->commandBuffer, args->depthCompareOp); } static void @@ -712,9 +721,10 @@ vkr_dispatch_vkCmdSetDepthTestEnable(UNUSED struct vn_dispatch_context *dispatch struct vn_command_vkCmdSetDepthTestEnable *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdSetDepthTestEnable_args_handle(args); - cmd->device->cmd_set_depth_test_enable(args->commandBuffer, args->depthTestEnable); + vk->CmdSetDepthTestEnable(args->commandBuffer, args->depthTestEnable); } static void @@ -722,9 +732,10 @@ vkr_dispatch_vkCmdSetDepthWriteEnable(UNUSED struct vn_dispatch_context *dispatc struct vn_command_vkCmdSetDepthWriteEnable *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdSetDepthWriteEnable_args_handle(args); - cmd->device->cmd_set_depth_write_enable(args->commandBuffer, args->depthWriteEnable); + vk->CmdSetDepthWriteEnable(args->commandBuffer, args->depthWriteEnable); } static void @@ -732,9 +743,10 @@ vkr_dispatch_vkCmdSetFrontFace(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetFrontFace *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdSetFrontFace_args_handle(args); - cmd->device->cmd_set_front_face(args->commandBuffer, args->frontFace); + vk->CmdSetFrontFace(args->commandBuffer, args->frontFace); } static void @@ -742,9 +754,10 @@ vkr_dispatch_vkCmdSetPrimitiveTopology(UNUSED struct vn_dispatch_context *dispat struct vn_command_vkCmdSetPrimitiveTopology *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdSetPrimitiveTopology_args_handle(args); - cmd->device->cmd_set_primitive_topology(args->commandBuffer, args->primitiveTopology); + vk->CmdSetPrimitiveTopology(args->commandBuffer, args->primitiveTopology); } static void @@ -752,10 +765,10 @@ vkr_dispatch_vkCmdSetScissorWithCount(UNUSED struct vn_dispatch_context *dispatc struct vn_command_vkCmdSetScissorWithCount *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdSetScissorWithCount_args_handle(args); - cmd->device->cmd_set_scissor_with_count(args->commandBuffer, args->scissorCount, - args->pScissors); + vk->CmdSetScissorWithCount(args->commandBuffer, args->scissorCount, args->pScissors); } static void @@ -763,10 +776,11 @@ vkr_dispatch_vkCmdSetStencilOp(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetStencilOp *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdSetStencilOp_args_handle(args); - cmd->device->cmd_set_stencil_op(args->commandBuffer, args->faceMask, args->failOp, - args->passOp, args->depthFailOp, args->compareOp); + vk->CmdSetStencilOp(args->commandBuffer, args->faceMask, args->failOp, args->passOp, + args->depthFailOp, args->compareOp); } static void @@ -774,9 +788,10 @@ vkr_dispatch_vkCmdSetStencilTestEnable(UNUSED struct vn_dispatch_context *dispat struct vn_command_vkCmdSetStencilTestEnable *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdSetStencilTestEnable_args_handle(args); - cmd->device->cmd_set_stencil_test_enable(args->commandBuffer, args->stencilTestEnable); + vk->CmdSetStencilTestEnable(args->commandBuffer, args->stencilTestEnable); } static void @@ -784,10 +799,11 @@ vkr_dispatch_vkCmdSetViewportWithCount(UNUSED struct vn_dispatch_context *dispat struct vn_command_vkCmdSetViewportWithCount *args) { struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; vn_replace_vkCmdSetViewportWithCount_args_handle(args); - cmd->device->cmd_set_viewport_with_count(args->commandBuffer, args->viewportCount, - args->pViewports); + vk->CmdSetViewportWithCount(args->commandBuffer, args->viewportCount, + args->pViewports); } void diff --git a/src/venus/vkr_device.c b/src/venus/vkr_device.c index abbcfafde..c42a1608a 100644 --- a/src/venus/vkr_device.c +++ b/src/venus/vkr_device.c @@ -61,164 +61,6 @@ vkr_device_create_queues(struct vkr_context *ctx, return VK_SUCCESS; } -static void -vkr_device_init_entry_points(struct vkr_device *dev, uint32_t api_version) -{ - VkDevice handle = dev->base.handle.device; - if (api_version >= VK_API_VERSION_1_2) { - dev->GetSemaphoreCounterValue = (PFN_vkGetSemaphoreCounterValue)vkGetDeviceProcAddr( - handle, "vkGetSemaphoreCounterValue"); - dev->WaitSemaphores = - (PFN_vkWaitSemaphores)vkGetDeviceProcAddr(handle, "vkWaitSemaphores"); - dev->SignalSemaphore = - (PFN_vkSignalSemaphore)vkGetDeviceProcAddr(handle, "vkSignalSemaphore"); - dev->GetDeviceMemoryOpaqueCaptureAddress = - (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)vkGetDeviceProcAddr( - handle, "vkGetDeviceMemoryOpaqueCaptureAddress"); - dev->GetBufferOpaqueCaptureAddress = - (PFN_vkGetBufferOpaqueCaptureAddress)vkGetDeviceProcAddr( - handle, "vkGetBufferOpaqueCaptureAddress"); - dev->GetBufferDeviceAddress = (PFN_vkGetBufferDeviceAddress)vkGetDeviceProcAddr( - handle, "vkGetBufferDeviceAddress"); - dev->ResetQueryPool = - (PFN_vkResetQueryPool)vkGetDeviceProcAddr(handle, "vkResetQueryPool"); - dev->CreateRenderPass2 = - (PFN_vkCreateRenderPass2)vkGetDeviceProcAddr(handle, "vkCreateRenderPass2"); - dev->CmdBeginRenderPass2 = - (PFN_vkCmdBeginRenderPass2)vkGetDeviceProcAddr(handle, "vkCmdBeginRenderPass2"); - dev->CmdNextSubpass2 = - (PFN_vkCmdNextSubpass2)vkGetDeviceProcAddr(handle, "vkCmdNextSubpass2"); - dev->CmdEndRenderPass2 = - (PFN_vkCmdEndRenderPass2)vkGetDeviceProcAddr(handle, "vkCmdEndRenderPass2"); - dev->CmdDrawIndirectCount = (PFN_vkCmdDrawIndirectCount)vkGetDeviceProcAddr( - handle, "vkCmdDrawIndirectCount"); - dev->CmdDrawIndexedIndirectCount = - (PFN_vkCmdDrawIndexedIndirectCount)vkGetDeviceProcAddr( - handle, "vkCmdDrawIndexedIndirectCount"); - } else { - dev->GetSemaphoreCounterValue = (PFN_vkGetSemaphoreCounterValue)vkGetDeviceProcAddr( - handle, "vkGetSemaphoreCounterValueKHR"); - dev->WaitSemaphores = - (PFN_vkWaitSemaphores)vkGetDeviceProcAddr(handle, "vkWaitSemaphoresKHR"); - dev->SignalSemaphore = - (PFN_vkSignalSemaphore)vkGetDeviceProcAddr(handle, "vkSignalSemaphoreKHR"); - dev->GetDeviceMemoryOpaqueCaptureAddress = - (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)vkGetDeviceProcAddr( - handle, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"); - dev->GetBufferOpaqueCaptureAddress = - (PFN_vkGetBufferOpaqueCaptureAddress)vkGetDeviceProcAddr( - handle, "vkGetBufferOpaqueCaptureAddressKHR"); - dev->GetBufferDeviceAddress = (PFN_vkGetBufferDeviceAddress)vkGetDeviceProcAddr( - handle, "vkGetBufferDeviceAddressKHR"); - dev->ResetQueryPool = - (PFN_vkResetQueryPool)vkGetDeviceProcAddr(handle, "vkResetQueryPoolEXT"); - dev->CreateRenderPass2 = - (PFN_vkCreateRenderPass2)vkGetDeviceProcAddr(handle, "vkCreateRenderPass2KHR"); - dev->CmdBeginRenderPass2 = (PFN_vkCmdBeginRenderPass2)vkGetDeviceProcAddr( - handle, "vkCmdBeginRenderPass2KHR"); - dev->CmdNextSubpass2 = - (PFN_vkCmdNextSubpass2)vkGetDeviceProcAddr(handle, "vkCmdNextSubpass2KHR"); - dev->CmdEndRenderPass2 = - (PFN_vkCmdEndRenderPass2)vkGetDeviceProcAddr(handle, "vkCmdEndRenderPass2KHR"); - dev->CmdDrawIndirectCount = (PFN_vkCmdDrawIndirectCount)vkGetDeviceProcAddr( - handle, "vkCmdDrawIndirectCountKHR"); - dev->CmdDrawIndexedIndirectCount = - (PFN_vkCmdDrawIndexedIndirectCount)vkGetDeviceProcAddr( - handle, "vkCmdDrawIndexedIndirectCountKHR"); - } - - if (api_version >= VK_API_VERSION_1_3) { - dev->cmd_bind_vertex_buffers_2 = (PFN_vkCmdBindVertexBuffers2)vkGetDeviceProcAddr( - handle, "vkCmdBindVertexBuffers2"); - dev->cmd_set_cull_mode = - (PFN_vkCmdSetCullMode)vkGetDeviceProcAddr(handle, "vkCmdSetCullMode"); - dev->cmd_set_depth_bounds_test_enable = - (PFN_vkCmdSetDepthBoundsTestEnable)vkGetDeviceProcAddr( - handle, "vkCmdSetDepthBoundsTestEnable"); - dev->cmd_set_depth_compare_op = (PFN_vkCmdSetDepthCompareOp)vkGetDeviceProcAddr( - handle, "vkCmdSetDepthCompareOp"); - dev->cmd_set_depth_test_enable = (PFN_vkCmdSetDepthTestEnable)vkGetDeviceProcAddr( - handle, "vkCmdSetDepthTestEnable"); - dev->cmd_set_depth_write_enable = (PFN_vkCmdSetDepthWriteEnable)vkGetDeviceProcAddr( - handle, "vkCmdSetDepthWriteEnable"); - dev->cmd_set_front_face = - (PFN_vkCmdSetFrontFace)vkGetDeviceProcAddr(handle, "vkCmdSetFrontFace"); - dev->cmd_set_primitive_topology = - (PFN_vkCmdSetPrimitiveTopology)vkGetDeviceProcAddr(handle, - "vkCmdSetPrimitiveTopology"); - dev->cmd_set_scissor_with_count = (PFN_vkCmdSetScissorWithCount)vkGetDeviceProcAddr( - handle, "vkCmdSetScissorWithCount"); - dev->cmd_set_stencil_op = - (PFN_vkCmdSetStencilOp)vkGetDeviceProcAddr(handle, "vkCmdSetStencilOp"); - dev->cmd_set_stencil_test_enable = - (PFN_vkCmdSetStencilTestEnable)vkGetDeviceProcAddr(handle, - "vkCmdSetStencilTestEnable"); - dev->cmd_set_viewport_with_count = - (PFN_vkCmdSetViewportWithCount)vkGetDeviceProcAddr(handle, - "vkCmdSetViewportWithCount"); - } else { - dev->cmd_bind_vertex_buffers_2 = (PFN_vkCmdBindVertexBuffers2)vkGetDeviceProcAddr( - handle, "vkCmdBindVertexBuffers2EXT"); - dev->cmd_set_cull_mode = - (PFN_vkCmdSetCullMode)vkGetDeviceProcAddr(handle, "vkCmdSetCullModeEXT"); - dev->cmd_set_depth_bounds_test_enable = - (PFN_vkCmdSetDepthBoundsTestEnable)vkGetDeviceProcAddr( - handle, "vkCmdSetDepthBoundsTestEnableEXT"); - dev->cmd_set_depth_compare_op = (PFN_vkCmdSetDepthCompareOp)vkGetDeviceProcAddr( - handle, "vkCmdSetDepthCompareOpEXT"); - dev->cmd_set_depth_test_enable = (PFN_vkCmdSetDepthTestEnable)vkGetDeviceProcAddr( - handle, "vkCmdSetDepthTestEnableEXT"); - dev->cmd_set_depth_write_enable = (PFN_vkCmdSetDepthWriteEnable)vkGetDeviceProcAddr( - handle, "vkCmdSetDepthWriteEnableEXT"); - dev->cmd_set_front_face = - (PFN_vkCmdSetFrontFace)vkGetDeviceProcAddr(handle, "vkCmdSetFrontFaceEXT"); - dev->cmd_set_primitive_topology = - (PFN_vkCmdSetPrimitiveTopology)vkGetDeviceProcAddr( - handle, "vkCmdSetPrimitiveTopologyEXT"); - dev->cmd_set_scissor_with_count = (PFN_vkCmdSetScissorWithCount)vkGetDeviceProcAddr( - handle, "vkCmdSetScissorWithCountEXT"); - dev->cmd_set_stencil_op = - (PFN_vkCmdSetStencilOp)vkGetDeviceProcAddr(handle, "vkCmdSetStencilOpEXT"); - dev->cmd_set_stencil_test_enable = - (PFN_vkCmdSetStencilTestEnable)vkGetDeviceProcAddr( - handle, "vkCmdSetStencilTestEnableEXT"); - dev->cmd_set_viewport_with_count = - (PFN_vkCmdSetViewportWithCount)vkGetDeviceProcAddr( - handle, "vkCmdSetViewportWithCountEXT"); - } - - dev->cmd_set_line_stipple = - (PFN_vkCmdSetLineStippleEXT)vkGetDeviceProcAddr(handle, "vkCmdSetLineStippleEXT"); - - dev->cmd_bind_transform_feedback_buffers = - (PFN_vkCmdBindTransformFeedbackBuffersEXT)vkGetDeviceProcAddr( - handle, "vkCmdBindTransformFeedbackBuffersEXT"); - dev->cmd_begin_transform_feedback = - (PFN_vkCmdBeginTransformFeedbackEXT)vkGetDeviceProcAddr( - handle, "vkCmdBeginTransformFeedbackEXT"); - dev->cmd_end_transform_feedback = - (PFN_vkCmdEndTransformFeedbackEXT)vkGetDeviceProcAddr( - handle, "vkCmdEndTransformFeedbackEXT"); - dev->cmd_begin_query_indexed = (PFN_vkCmdBeginQueryIndexedEXT)vkGetDeviceProcAddr( - handle, "vkCmdBeginQueryIndexedEXT"); - dev->cmd_end_query_indexed = - (PFN_vkCmdEndQueryIndexedEXT)vkGetDeviceProcAddr(handle, "vkCmdEndQueryIndexedEXT"); - dev->cmd_draw_indirect_byte_count = - (PFN_vkCmdDrawIndirectByteCountEXT)vkGetDeviceProcAddr( - handle, "vkCmdDrawIndirectByteCountEXT"); - - dev->get_image_drm_format_modifier_properties = - (PFN_vkGetImageDrmFormatModifierPropertiesEXT)vkGetDeviceProcAddr( - handle, "vkGetImageDrmFormatModifierPropertiesEXT"); - - dev->get_fence_fd = - (PFN_vkGetFenceFdKHR)vkGetDeviceProcAddr(handle, "vkGetFenceFdKHR"); - dev->get_memory_fd = - (PFN_vkGetMemoryFdKHR)vkGetDeviceProcAddr(handle, "vkGetMemoryFdKHR"); - dev->get_memory_fd_properties = (PFN_vkGetMemoryFdPropertiesKHR)vkGetDeviceProcAddr( - handle, "vkGetMemoryFdPropertiesKHR"); -} - static void vkr_device_init_proc_table(struct vkr_device *dev, uint32_t api_version, @@ -299,8 +141,6 @@ vkr_dispatch_vkCreateDevice(struct vn_dispatch_context *dispatch, return; } - vkr_device_init_entry_points(dev, physical_dev->api_version); - mtx_init(&dev->free_sync_mutex, mtx_plain); list_inithead(&dev->free_syncs); diff --git a/src/venus/vkr_device.h b/src/venus/vkr_device.h index 1c510d74a..4a5a10967 100644 --- a/src/venus/vkr_device.h +++ b/src/venus/vkr_device.h @@ -18,50 +18,6 @@ struct vkr_device { struct vn_device_proc_table proc_table; - /* Vulkan 1.2 */ - PFN_vkGetSemaphoreCounterValue GetSemaphoreCounterValue; - PFN_vkWaitSemaphores WaitSemaphores; - PFN_vkSignalSemaphore SignalSemaphore; - PFN_vkGetDeviceMemoryOpaqueCaptureAddress GetDeviceMemoryOpaqueCaptureAddress; - PFN_vkGetBufferOpaqueCaptureAddress GetBufferOpaqueCaptureAddress; - PFN_vkGetBufferDeviceAddress GetBufferDeviceAddress; - PFN_vkResetQueryPool ResetQueryPool; - PFN_vkCreateRenderPass2 CreateRenderPass2; - PFN_vkCmdBeginRenderPass2 CmdBeginRenderPass2; - PFN_vkCmdNextSubpass2 CmdNextSubpass2; - PFN_vkCmdEndRenderPass2 CmdEndRenderPass2; - PFN_vkCmdDrawIndirectCount CmdDrawIndirectCount; - PFN_vkCmdDrawIndexedIndirectCount CmdDrawIndexedIndirectCount; - - /* Vulkan 1.3 */ - PFN_vkCmdBindVertexBuffers2 cmd_bind_vertex_buffers_2; - PFN_vkCmdSetCullMode cmd_set_cull_mode; - PFN_vkCmdSetDepthBoundsTestEnable cmd_set_depth_bounds_test_enable; - PFN_vkCmdSetDepthCompareOp cmd_set_depth_compare_op; - PFN_vkCmdSetDepthTestEnable cmd_set_depth_test_enable; - PFN_vkCmdSetDepthWriteEnable cmd_set_depth_write_enable; - PFN_vkCmdSetFrontFace cmd_set_front_face; - PFN_vkCmdSetPrimitiveTopology cmd_set_primitive_topology; - PFN_vkCmdSetScissorWithCount cmd_set_scissor_with_count; - PFN_vkCmdSetStencilOp cmd_set_stencil_op; - PFN_vkCmdSetStencilTestEnable cmd_set_stencil_test_enable; - PFN_vkCmdSetViewportWithCount cmd_set_viewport_with_count; - - PFN_vkCmdSetLineStippleEXT cmd_set_line_stipple; - - PFN_vkCmdBindTransformFeedbackBuffersEXT cmd_bind_transform_feedback_buffers; - PFN_vkCmdBeginTransformFeedbackEXT cmd_begin_transform_feedback; - PFN_vkCmdEndTransformFeedbackEXT cmd_end_transform_feedback; - PFN_vkCmdBeginQueryIndexedEXT cmd_begin_query_indexed; - PFN_vkCmdEndQueryIndexedEXT cmd_end_query_indexed; - PFN_vkCmdDrawIndirectByteCountEXT cmd_draw_indirect_byte_count; - - PFN_vkGetImageDrmFormatModifierPropertiesEXT get_image_drm_format_modifier_properties; - - PFN_vkGetFenceFdKHR get_fence_fd; - PFN_vkGetMemoryFdKHR get_memory_fd; - PFN_vkGetMemoryFdPropertiesKHR get_memory_fd_properties; - struct list_head queues; mtx_t free_sync_mutex; diff --git a/src/venus/vkr_device_memory.c b/src/venus/vkr_device_memory.c index 2b48b4eb2..5e11a9a84 100644 --- a/src/venus/vkr_device_memory.c +++ b/src/venus/vkr_device_memory.c @@ -256,9 +256,10 @@ vkr_dispatch_vkGetDeviceMemoryOpaqueCaptureAddress( struct vn_command_vkGetDeviceMemoryOpaqueCaptureAddress *args) { struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; vn_replace_vkGetDeviceMemoryOpaqueCaptureAddress_args_handle(args); - args->ret = dev->GetDeviceMemoryOpaqueCaptureAddress(args->device, args->pInfo); + args->ret = vk->GetDeviceMemoryOpaqueCaptureAddress(args->device, args->pInfo); } static void @@ -268,6 +269,7 @@ vkr_dispatch_vkGetMemoryResourcePropertiesMESA( { struct vkr_context *ctx = dispatch->data; struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; struct vkr_resource_attachment *att = vkr_context_get_resource(ctx, args->resourceId); if (!att) { @@ -293,8 +295,7 @@ vkr_dispatch_vkGetMemoryResourcePropertiesMESA( .memoryTypeBits = 0, }; vn_replace_vkGetMemoryResourcePropertiesMESA_args_handle(args); - args->ret = - dev->get_memory_fd_properties(args->device, handle_type, fd, &mem_fd_props); + args->ret = vk->GetMemoryFdPropertiesKHR(args->device, handle_type, fd, &mem_fd_props); if (args->ret != VK_SUCCESS) { close(fd); return; @@ -343,6 +344,7 @@ vkr_device_memory_export_fd(struct vkr_device_memory *mem, VkExternalMemoryHandleTypeFlagBits handle_type, int *out_fd) { + struct vn_device_proc_table *vk = &mem->device->proc_table; int fd = -1; if (mem->gbm_bo) { @@ -362,7 +364,7 @@ vkr_device_memory_export_fd(struct vkr_device_memory *mem, .memory = mem_handle, .handleType = handle_type, }; - VkResult result = mem->device->get_memory_fd(dev_handle, &fd_info, &fd); + VkResult result = vk->GetMemoryFdKHR(dev_handle, &fd_info, &fd); if (result != VK_SUCCESS) return result == VK_ERROR_TOO_MANY_OBJECTS ? -EMFILE : -ENOMEM; } diff --git a/src/venus/vkr_image.c b/src/venus/vkr_image.c index 993910f2d..8df730809 100644 --- a/src/venus/vkr_image.c +++ b/src/venus/vkr_image.c @@ -114,10 +114,11 @@ vkr_dispatch_vkGetImageDrmFormatModifierPropertiesEXT( struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT *args) { struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; vn_replace_vkGetImageDrmFormatModifierPropertiesEXT_args_handle(args); - args->ret = dev->get_image_drm_format_modifier_properties(args->device, args->image, - args->pProperties); + args->ret = vk->GetImageDrmFormatModifierPropertiesEXT(args->device, args->image, + args->pProperties); } static void diff --git a/src/venus/vkr_query_pool.c b/src/venus/vkr_query_pool.c index ed16d17c4..8f10fccf4 100644 --- a/src/venus/vkr_query_pool.c +++ b/src/venus/vkr_query_pool.c @@ -36,9 +36,10 @@ vkr_dispatch_vkResetQueryPool(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkResetQueryPool *args) { struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; vn_replace_vkResetQueryPool_args_handle(args); - dev->ResetQueryPool(args->device, args->queryPool, args->firstQuery, args->queryCount); + vk->ResetQueryPool(args->device, args->queryPool, args->firstQuery, args->queryCount); } void diff --git a/src/venus/vkr_queue.c b/src/venus/vkr_queue.c index c83c01294..4425c754b 100644 --- a/src/venus/vkr_queue.c +++ b/src/venus/vkr_queue.c @@ -459,9 +459,10 @@ vkr_dispatch_vkGetSemaphoreCounterValue(UNUSED struct vn_dispatch_context *dispa struct vn_command_vkGetSemaphoreCounterValue *args) { struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; vn_replace_vkGetSemaphoreCounterValue_args_handle(args); - args->ret = dev->GetSemaphoreCounterValue(args->device, args->semaphore, args->pValue); + args->ret = vk->GetSemaphoreCounterValue(args->device, args->semaphore, args->pValue); } static void @@ -470,6 +471,7 @@ vkr_dispatch_vkWaitSemaphores(struct vn_dispatch_context *dispatch, { struct vkr_context *ctx = dispatch->data; struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; /* no blocking call */ if (args->timeout) { @@ -478,7 +480,7 @@ vkr_dispatch_vkWaitSemaphores(struct vn_dispatch_context *dispatch, } vn_replace_vkWaitSemaphores_args_handle(args); - args->ret = dev->WaitSemaphores(args->device, args->pWaitInfo, args->timeout); + args->ret = vk->WaitSemaphores(args->device, args->pWaitInfo, args->timeout); } static void @@ -486,9 +488,10 @@ vkr_dispatch_vkSignalSemaphore(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkSignalSemaphore *args) { struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; vn_replace_vkSignalSemaphore_args_handle(args); - args->ret = dev->SignalSemaphore(args->device, args->pSignalInfo); + args->ret = vk->SignalSemaphore(args->device, args->pSignalInfo); } static void diff --git a/src/venus/vkr_render_pass.c b/src/venus/vkr_render_pass.c index 6f0d1e36a..1aa44bd75 100644 --- a/src/venus/vkr_render_pass.c +++ b/src/venus/vkr_render_pass.c @@ -20,6 +20,7 @@ vkr_dispatch_vkCreateRenderPass2(struct vn_dispatch_context *dispatch, { struct vkr_context *ctx = dispatch->data; struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; struct vkr_render_pass *pass = vkr_context_alloc_object( ctx, sizeof(*pass), VK_OBJECT_TYPE_RENDER_PASS, args->pRenderPass); @@ -29,8 +30,8 @@ vkr_dispatch_vkCreateRenderPass2(struct vn_dispatch_context *dispatch, } vn_replace_vkCreateRenderPass2_args_handle(args); - args->ret = dev->CreateRenderPass2(args->device, args->pCreateInfo, NULL, - &pass->base.handle.render_pass); + args->ret = vk->CreateRenderPass2(args->device, args->pCreateInfo, NULL, + &pass->base.handle.render_pass); if (args->ret != VK_SUCCESS) { free(pass); return; -- GitLab From 0a871315e57166babbaf82963fb54cf694124f15 Mon Sep 17 00:00:00 2001 From: Igor Torrente Date: Wed, 9 Mar 2022 09:03:16 -0300 Subject: [PATCH 4/5] vkr: Modify vkr_device_from_handle.py to use proc-table From a performance standpoint, is preferable to use the proc-table and avoid the loader trampoline. Signed-off-by: Igor Torrente Part-of: --- src/venus/vkr_device_object.py | 32 +++++++++++++++++++++++++++----- 1 file changed, 27 insertions(+), 5 deletions(-) diff --git a/src/venus/vkr_device_object.py b/src/venus/vkr_device_object.py index c83de9452..c45be01fe 100644 --- a/src/venus/vkr_device_object.py +++ b/src/venus/vkr_device_object.py @@ -13,9 +13,12 @@ vkr_{create_func_name}_create_driver_handle( struct vn_command_{create_cmd} *args, struct vkr_{vkr_type} *obj) {{ + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + /* handles in args are replaced */ vn_replace_{create_cmd}_args_handle(args); - args->ret = {create_cmd}(args->device, args->{create_info}, NULL, + args->ret = vk->{proc_create}(args->device, args->{create_info}, NULL, &obj->base.handle.{vkr_type}); return args->ret; }} @@ -31,9 +34,12 @@ VkResult vkr_{create_func_name}_create_driver_handles( struct vn_command_{create_cmd} *args, struct object_array *arr) {{ + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + /* handles in args are replaced */ vn_replace_{create_cmd}_args_handle(args); - args->ret = {create_cmd}(args->device, args->{create_info}, + args->ret = vk->{proc_create}(args->device, args->{create_info}, arr->handle_storage); return args->ret; }} @@ -47,9 +53,12 @@ vkr_{create_func_name}_create_driver_handles( struct vn_command_{create_cmd} *args, struct object_array *arr) {{ + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + /* handles in args are replaced */ vn_replace_{create_cmd}_args_handle(args); - args->ret = {create_cmd}(args->device, args->{create_cache}, + args->ret = vk->{proc_create}(args->device, args->{create_cache}, args->{create_count}, args->{create_info}, NULL, arr->handle_storage); return args->ret; @@ -63,9 +72,12 @@ vkr_{destroy_func_name}_destroy_driver_handle( UNUSED struct vkr_context *ctx, struct vn_command_{destroy_cmd} *args) {{ + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + /* handles in args are replaced */ vn_replace_{destroy_cmd}_args_handle(args); - {destroy_cmd}(args->device, args->{destroy_obj}, NULL); + vk->{proc_destroy}(args->device, args->{destroy_obj}, NULL); }} ''' @@ -79,6 +91,9 @@ vkr_{destroy_func_name}_destroy_driver_handles( struct vn_command_{destroy_cmd} *args, struct list_head *free_list) {{ + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + list_inithead(free_list); for (uint32_t i = 0; i < args->{destroy_count}; i++) {{ struct vkr_{vkr_type} *obj = @@ -92,7 +107,7 @@ vkr_{destroy_func_name}_destroy_driver_handles( /* handles in args are replaced */ vn_replace_{destroy_cmd}_args_handle(args); - {destroy_cmd}(args->device, args->{destroy_pool}, + vk->{proc_destroy}(args->device, args->{destroy_pool}, args->{destroy_count}, args->{destroy_objs}); }} ''' @@ -428,6 +443,13 @@ def process_objects(json_objs): json_obj.setdefault('create_func_name', json_obj['vkr_type']) json_obj.setdefault('destroy_func_name', json_obj['vkr_type']) json_obj.setdefault('variants', []) + json_obj['proc_create'] = json_obj.get('create_cmd')[2:] + json_obj['proc_destroy'] = json_obj.get('destroy_cmd')[2:] + for variant in json_obj.get('variants'): + if variant.get('create_cmd') != None: + variant['proc_create'] = variant.get('create_cmd')[2:] + if variant.get('destroy_cmd') != None: + variant['proc_destroy'] = variant.get('create_cmd')[2:] def file_generator(json_file): contents = file_header_generator(json_file) -- GitLab From 967f2952f066c6c0d5e0075c43c7a362d7fa6a51 Mon Sep 17 00:00:00 2001 From: Igor Torrente Date: Wed, 9 Mar 2022 09:09:39 -0300 Subject: [PATCH 5/5] vkr: Replace direct use of vk* cmd with proc-table Replaces all the direct vk* calls with the proc-table to avoid using the loader trampoline. Signed-off-by: Igor Torrente Part-of: --- src/venus/vkr_buffer.c | 20 +- src/venus/vkr_command_buffer.c | 340 ++++++++++++++++++++++++--------- src/venus/vkr_context.c | 4 +- src/venus/vkr_descriptor_set.c | 19 +- src/venus/vkr_device.c | 69 ++++--- src/venus/vkr_device_memory.c | 6 +- src/venus/vkr_image.c | 45 +++-- src/venus/vkr_pipeline.c | 14 +- src/venus/vkr_query_pool.c | 9 +- src/venus/vkr_queue.c | 59 ++++-- src/venus/vkr_render_pass.c | 5 +- 11 files changed, 420 insertions(+), 170 deletions(-) diff --git a/src/venus/vkr_buffer.c b/src/venus/vkr_buffer.c index bdc239187..2045bb9f7 100644 --- a/src/venus/vkr_buffer.c +++ b/src/venus/vkr_buffer.c @@ -52,8 +52,11 @@ vkr_dispatch_vkGetBufferMemoryRequirements( UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetBufferMemoryRequirements *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetBufferMemoryRequirements_args_handle(args); - vkGetBufferMemoryRequirements(args->device, args->buffer, args->pMemoryRequirements); + vk->GetBufferMemoryRequirements(args->device, args->buffer, args->pMemoryRequirements); } static void @@ -61,25 +64,34 @@ vkr_dispatch_vkGetBufferMemoryRequirements2( UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetBufferMemoryRequirements2 *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetBufferMemoryRequirements2_args_handle(args); - vkGetBufferMemoryRequirements2(args->device, args->pInfo, args->pMemoryRequirements); + vk->GetBufferMemoryRequirements2(args->device, args->pInfo, args->pMemoryRequirements); } static void vkr_dispatch_vkBindBufferMemory(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkBindBufferMemory *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkBindBufferMemory_args_handle(args); args->ret = - vkBindBufferMemory(args->device, args->buffer, args->memory, args->memoryOffset); + vk->BindBufferMemory(args->device, args->buffer, args->memory, args->memoryOffset); } static void vkr_dispatch_vkBindBufferMemory2(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkBindBufferMemory2 *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkBindBufferMemory2_args_handle(args); - args->ret = vkBindBufferMemory2(args->device, args->bindInfoCount, args->pBindInfos); + args->ret = vk->BindBufferMemory2(args->device, args->bindInfoCount, args->pBindInfos); } static void diff --git a/src/venus/vkr_command_buffer.c b/src/venus/vkr_command_buffer.c index 6d9e964ae..a9a4b875e 100644 --- a/src/venus/vkr_command_buffer.c +++ b/src/venus/vkr_command_buffer.c @@ -36,16 +36,22 @@ static void vkr_dispatch_vkResetCommandPool(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkResetCommandPool *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkResetCommandPool_args_handle(args); - args->ret = vkResetCommandPool(args->device, args->commandPool, args->flags); + args->ret = vk->ResetCommandPool(args->device, args->commandPool, args->flags); } static void vkr_dispatch_vkTrimCommandPool(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkTrimCommandPool *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkTrimCommandPool_args_handle(args); - vkTrimCommandPool(args->device, args->commandPool, args->flags); + vk->TrimCommandPool(args->device, args->commandPool, args->flags); } static void @@ -90,262 +96,353 @@ static void vkr_dispatch_vkResetCommandBuffer(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkResetCommandBuffer *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkResetCommandBuffer_args_handle(args); - args->ret = vkResetCommandBuffer(args->commandBuffer, args->flags); + args->ret = vk->ResetCommandBuffer(args->commandBuffer, args->flags); } static void vkr_dispatch_vkBeginCommandBuffer(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkBeginCommandBuffer *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkBeginCommandBuffer_args_handle(args); - args->ret = vkBeginCommandBuffer(args->commandBuffer, args->pBeginInfo); + args->ret = vk->BeginCommandBuffer(args->commandBuffer, args->pBeginInfo); } static void vkr_dispatch_vkEndCommandBuffer(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkEndCommandBuffer *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkEndCommandBuffer_args_handle(args); - args->ret = vkEndCommandBuffer(args->commandBuffer); + args->ret = vk->EndCommandBuffer(args->commandBuffer); } static void vkr_dispatch_vkCmdBindPipeline(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdBindPipeline *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdBindPipeline_args_handle(args); - vkCmdBindPipeline(args->commandBuffer, args->pipelineBindPoint, args->pipeline); + vk->CmdBindPipeline(args->commandBuffer, args->pipelineBindPoint, args->pipeline); } static void vkr_dispatch_vkCmdSetViewport(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetViewport *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdSetViewport_args_handle(args); - vkCmdSetViewport(args->commandBuffer, args->firstViewport, args->viewportCount, - args->pViewports); + vk->CmdSetViewport(args->commandBuffer, args->firstViewport, args->viewportCount, + args->pViewports); } static void vkr_dispatch_vkCmdSetScissor(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetScissor *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdSetScissor_args_handle(args); - vkCmdSetScissor(args->commandBuffer, args->firstScissor, args->scissorCount, - args->pScissors); + vk->CmdSetScissor(args->commandBuffer, args->firstScissor, args->scissorCount, + args->pScissors); } static void vkr_dispatch_vkCmdSetLineWidth(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetLineWidth *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdSetLineWidth_args_handle(args); - vkCmdSetLineWidth(args->commandBuffer, args->lineWidth); + vk->CmdSetLineWidth(args->commandBuffer, args->lineWidth); } static void vkr_dispatch_vkCmdSetDepthBias(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetDepthBias *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdSetDepthBias_args_handle(args); - vkCmdSetDepthBias(args->commandBuffer, args->depthBiasConstantFactor, - args->depthBiasClamp, args->depthBiasSlopeFactor); + vk->CmdSetDepthBias(args->commandBuffer, args->depthBiasConstantFactor, + args->depthBiasClamp, args->depthBiasSlopeFactor); } static void vkr_dispatch_vkCmdSetBlendConstants(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetBlendConstants *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdSetBlendConstants_args_handle(args); - vkCmdSetBlendConstants(args->commandBuffer, args->blendConstants); + vk->CmdSetBlendConstants(args->commandBuffer, args->blendConstants); } static void vkr_dispatch_vkCmdSetDepthBounds(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetDepthBounds *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdSetDepthBounds_args_handle(args); - vkCmdSetDepthBounds(args->commandBuffer, args->minDepthBounds, args->maxDepthBounds); + vk->CmdSetDepthBounds(args->commandBuffer, args->minDepthBounds, args->maxDepthBounds); } static void vkr_dispatch_vkCmdSetStencilCompareMask(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetStencilCompareMask *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdSetStencilCompareMask_args_handle(args); - vkCmdSetStencilCompareMask(args->commandBuffer, args->faceMask, args->compareMask); + vk->CmdSetStencilCompareMask(args->commandBuffer, args->faceMask, args->compareMask); } static void vkr_dispatch_vkCmdSetStencilWriteMask(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetStencilWriteMask *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdSetStencilWriteMask_args_handle(args); - vkCmdSetStencilWriteMask(args->commandBuffer, args->faceMask, args->writeMask); + vk->CmdSetStencilWriteMask(args->commandBuffer, args->faceMask, args->writeMask); } static void vkr_dispatch_vkCmdSetStencilReference(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetStencilReference *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdSetStencilReference_args_handle(args); - vkCmdSetStencilReference(args->commandBuffer, args->faceMask, args->reference); + vk->CmdSetStencilReference(args->commandBuffer, args->faceMask, args->reference); } static void vkr_dispatch_vkCmdBindDescriptorSets(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdBindDescriptorSets *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdBindDescriptorSets_args_handle(args); - vkCmdBindDescriptorSets(args->commandBuffer, args->pipelineBindPoint, args->layout, - args->firstSet, args->descriptorSetCount, - args->pDescriptorSets, args->dynamicOffsetCount, - args->pDynamicOffsets); + vk->CmdBindDescriptorSets(args->commandBuffer, args->pipelineBindPoint, args->layout, + args->firstSet, args->descriptorSetCount, + args->pDescriptorSets, args->dynamicOffsetCount, + args->pDynamicOffsets); } static void vkr_dispatch_vkCmdBindIndexBuffer(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdBindIndexBuffer *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdBindIndexBuffer_args_handle(args); - vkCmdBindIndexBuffer(args->commandBuffer, args->buffer, args->offset, args->indexType); + vk->CmdBindIndexBuffer(args->commandBuffer, args->buffer, args->offset, + args->indexType); } static void vkr_dispatch_vkCmdBindVertexBuffers(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdBindVertexBuffers *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdBindVertexBuffers_args_handle(args); - vkCmdBindVertexBuffers(args->commandBuffer, args->firstBinding, args->bindingCount, - args->pBuffers, args->pOffsets); + vk->CmdBindVertexBuffers(args->commandBuffer, args->firstBinding, args->bindingCount, + args->pBuffers, args->pOffsets); } static void vkr_dispatch_vkCmdDraw(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdDraw *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdDraw_args_handle(args); - vkCmdDraw(args->commandBuffer, args->vertexCount, args->instanceCount, - args->firstVertex, args->firstInstance); + vk->CmdDraw(args->commandBuffer, args->vertexCount, args->instanceCount, + args->firstVertex, args->firstInstance); } static void vkr_dispatch_vkCmdDrawIndexed(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdDrawIndexed *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdDrawIndexed_args_handle(args); - vkCmdDrawIndexed(args->commandBuffer, args->indexCount, args->instanceCount, - args->firstIndex, args->vertexOffset, args->firstInstance); + vk->CmdDrawIndexed(args->commandBuffer, args->indexCount, args->instanceCount, + args->firstIndex, args->vertexOffset, args->firstInstance); } static void vkr_dispatch_vkCmdDrawIndirect(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdDrawIndirect *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdDrawIndirect_args_handle(args); - vkCmdDrawIndirect(args->commandBuffer, args->buffer, args->offset, args->drawCount, - args->stride); + vk->CmdDrawIndirect(args->commandBuffer, args->buffer, args->offset, args->drawCount, + args->stride); } static void vkr_dispatch_vkCmdDrawIndexedIndirect(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdDrawIndexedIndirect *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdDrawIndexedIndirect_args_handle(args); - vkCmdDrawIndexedIndirect(args->commandBuffer, args->buffer, args->offset, - args->drawCount, args->stride); + vk->CmdDrawIndexedIndirect(args->commandBuffer, args->buffer, args->offset, + args->drawCount, args->stride); } static void vkr_dispatch_vkCmdDispatch(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdDispatch *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdDispatch_args_handle(args); - vkCmdDispatch(args->commandBuffer, args->groupCountX, args->groupCountY, - args->groupCountZ); + vk->CmdDispatch(args->commandBuffer, args->groupCountX, args->groupCountY, + args->groupCountZ); } static void vkr_dispatch_vkCmdDispatchIndirect(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdDispatchIndirect *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdDispatchIndirect_args_handle(args); - vkCmdDispatchIndirect(args->commandBuffer, args->buffer, args->offset); + vk->CmdDispatchIndirect(args->commandBuffer, args->buffer, args->offset); } static void vkr_dispatch_vkCmdCopyBuffer(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdCopyBuffer *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdCopyBuffer_args_handle(args); - vkCmdCopyBuffer(args->commandBuffer, args->srcBuffer, args->dstBuffer, - args->regionCount, args->pRegions); + vk->CmdCopyBuffer(args->commandBuffer, args->srcBuffer, args->dstBuffer, + args->regionCount, args->pRegions); } static void vkr_dispatch_vkCmdCopyImage(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdCopyImage *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdCopyImage_args_handle(args); - vkCmdCopyImage(args->commandBuffer, args->srcImage, args->srcImageLayout, - args->dstImage, args->dstImageLayout, args->regionCount, - args->pRegions); + vk->CmdCopyImage(args->commandBuffer, args->srcImage, args->srcImageLayout, + args->dstImage, args->dstImageLayout, args->regionCount, + args->pRegions); } static void vkr_dispatch_vkCmdBlitImage(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdBlitImage *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdBlitImage_args_handle(args); - vkCmdBlitImage(args->commandBuffer, args->srcImage, args->srcImageLayout, - args->dstImage, args->dstImageLayout, args->regionCount, args->pRegions, - args->filter); + vk->CmdBlitImage(args->commandBuffer, args->srcImage, args->srcImageLayout, + args->dstImage, args->dstImageLayout, args->regionCount, + args->pRegions, args->filter); } static void vkr_dispatch_vkCmdCopyBufferToImage(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdCopyBufferToImage *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdCopyBufferToImage_args_handle(args); - vkCmdCopyBufferToImage(args->commandBuffer, args->srcBuffer, args->dstImage, - args->dstImageLayout, args->regionCount, args->pRegions); + vk->CmdCopyBufferToImage(args->commandBuffer, args->srcBuffer, args->dstImage, + args->dstImageLayout, args->regionCount, args->pRegions); } static void vkr_dispatch_vkCmdCopyImageToBuffer(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdCopyImageToBuffer *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdCopyImageToBuffer_args_handle(args); - vkCmdCopyImageToBuffer(args->commandBuffer, args->srcImage, args->srcImageLayout, - args->dstBuffer, args->regionCount, args->pRegions); + vk->CmdCopyImageToBuffer(args->commandBuffer, args->srcImage, args->srcImageLayout, + args->dstBuffer, args->regionCount, args->pRegions); } static void vkr_dispatch_vkCmdUpdateBuffer(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdUpdateBuffer *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdUpdateBuffer_args_handle(args); - vkCmdUpdateBuffer(args->commandBuffer, args->dstBuffer, args->dstOffset, - args->dataSize, args->pData); + vk->CmdUpdateBuffer(args->commandBuffer, args->dstBuffer, args->dstOffset, + args->dataSize, args->pData); } static void vkr_dispatch_vkCmdFillBuffer(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdFillBuffer *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdFillBuffer_args_handle(args); - vkCmdFillBuffer(args->commandBuffer, args->dstBuffer, args->dstOffset, args->size, - args->data); + vk->CmdFillBuffer(args->commandBuffer, args->dstBuffer, args->dstOffset, args->size, + args->data); } static void vkr_dispatch_vkCmdClearColorImage(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdClearColorImage *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdClearColorImage_args_handle(args); - vkCmdClearColorImage(args->commandBuffer, args->image, args->imageLayout, args->pColor, - args->rangeCount, args->pRanges); + vk->CmdClearColorImage(args->commandBuffer, args->image, args->imageLayout, + args->pColor, args->rangeCount, args->pRanges); } static void @@ -353,172 +450,229 @@ vkr_dispatch_vkCmdClearDepthStencilImage( UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdClearDepthStencilImage *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdClearDepthStencilImage_args_handle(args); - vkCmdClearDepthStencilImage(args->commandBuffer, args->image, args->imageLayout, - args->pDepthStencil, args->rangeCount, args->pRanges); + vk->CmdClearDepthStencilImage(args->commandBuffer, args->image, args->imageLayout, + args->pDepthStencil, args->rangeCount, args->pRanges); } static void vkr_dispatch_vkCmdClearAttachments(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdClearAttachments *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdClearAttachments_args_handle(args); - vkCmdClearAttachments(args->commandBuffer, args->attachmentCount, args->pAttachments, - args->rectCount, args->pRects); + vk->CmdClearAttachments(args->commandBuffer, args->attachmentCount, args->pAttachments, + args->rectCount, args->pRects); } static void vkr_dispatch_vkCmdResolveImage(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdResolveImage *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdResolveImage_args_handle(args); - vkCmdResolveImage(args->commandBuffer, args->srcImage, args->srcImageLayout, - args->dstImage, args->dstImageLayout, args->regionCount, - args->pRegions); + vk->CmdResolveImage(args->commandBuffer, args->srcImage, args->srcImageLayout, + args->dstImage, args->dstImageLayout, args->regionCount, + args->pRegions); } static void vkr_dispatch_vkCmdSetEvent(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetEvent *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdSetEvent_args_handle(args); - vkCmdSetEvent(args->commandBuffer, args->event, args->stageMask); + vk->CmdSetEvent(args->commandBuffer, args->event, args->stageMask); } static void vkr_dispatch_vkCmdResetEvent(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdResetEvent *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdResetEvent_args_handle(args); - vkCmdResetEvent(args->commandBuffer, args->event, args->stageMask); + vk->CmdResetEvent(args->commandBuffer, args->event, args->stageMask); } static void vkr_dispatch_vkCmdWaitEvents(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdWaitEvents *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdWaitEvents_args_handle(args); - vkCmdWaitEvents(args->commandBuffer, args->eventCount, args->pEvents, - args->srcStageMask, args->dstStageMask, args->memoryBarrierCount, - args->pMemoryBarriers, args->bufferMemoryBarrierCount, - args->pBufferMemoryBarriers, args->imageMemoryBarrierCount, - args->pImageMemoryBarriers); + vk->CmdWaitEvents(args->commandBuffer, args->eventCount, args->pEvents, + args->srcStageMask, args->dstStageMask, args->memoryBarrierCount, + args->pMemoryBarriers, args->bufferMemoryBarrierCount, + args->pBufferMemoryBarriers, args->imageMemoryBarrierCount, + args->pImageMemoryBarriers); } static void vkr_dispatch_vkCmdPipelineBarrier(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdPipelineBarrier *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdPipelineBarrier_args_handle(args); - vkCmdPipelineBarrier(args->commandBuffer, args->srcStageMask, args->dstStageMask, - args->dependencyFlags, args->memoryBarrierCount, - args->pMemoryBarriers, args->bufferMemoryBarrierCount, - args->pBufferMemoryBarriers, args->imageMemoryBarrierCount, - args->pImageMemoryBarriers); + vk->CmdPipelineBarrier(args->commandBuffer, args->srcStageMask, args->dstStageMask, + args->dependencyFlags, args->memoryBarrierCount, + args->pMemoryBarriers, args->bufferMemoryBarrierCount, + args->pBufferMemoryBarriers, args->imageMemoryBarrierCount, + args->pImageMemoryBarriers); } static void vkr_dispatch_vkCmdBeginQuery(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdBeginQuery *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdBeginQuery_args_handle(args); - vkCmdBeginQuery(args->commandBuffer, args->queryPool, args->query, args->flags); + vk->CmdBeginQuery(args->commandBuffer, args->queryPool, args->query, args->flags); } static void vkr_dispatch_vkCmdEndQuery(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdEndQuery *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdEndQuery_args_handle(args); - vkCmdEndQuery(args->commandBuffer, args->queryPool, args->query); + vk->CmdEndQuery(args->commandBuffer, args->queryPool, args->query); } static void vkr_dispatch_vkCmdResetQueryPool(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdResetQueryPool *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdResetQueryPool_args_handle(args); - vkCmdResetQueryPool(args->commandBuffer, args->queryPool, args->firstQuery, - args->queryCount); + vk->CmdResetQueryPool(args->commandBuffer, args->queryPool, args->firstQuery, + args->queryCount); } static void vkr_dispatch_vkCmdWriteTimestamp(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdWriteTimestamp *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdWriteTimestamp_args_handle(args); - vkCmdWriteTimestamp(args->commandBuffer, args->pipelineStage, args->queryPool, - args->query); + vk->CmdWriteTimestamp(args->commandBuffer, args->pipelineStage, args->queryPool, + args->query); } static void vkr_dispatch_vkCmdCopyQueryPoolResults(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdCopyQueryPoolResults *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdCopyQueryPoolResults_args_handle(args); - vkCmdCopyQueryPoolResults(args->commandBuffer, args->queryPool, args->firstQuery, - args->queryCount, args->dstBuffer, args->dstOffset, - args->stride, args->flags); + vk->CmdCopyQueryPoolResults(args->commandBuffer, args->queryPool, args->firstQuery, + args->queryCount, args->dstBuffer, args->dstOffset, + args->stride, args->flags); } static void vkr_dispatch_vkCmdPushConstants(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdPushConstants *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdPushConstants_args_handle(args); - vkCmdPushConstants(args->commandBuffer, args->layout, args->stageFlags, args->offset, - args->size, args->pValues); + vk->CmdPushConstants(args->commandBuffer, args->layout, args->stageFlags, args->offset, + args->size, args->pValues); } static void vkr_dispatch_vkCmdBeginRenderPass(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdBeginRenderPass *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdBeginRenderPass_args_handle(args); - vkCmdBeginRenderPass(args->commandBuffer, args->pRenderPassBegin, args->contents); + vk->CmdBeginRenderPass(args->commandBuffer, args->pRenderPassBegin, args->contents); } static void vkr_dispatch_vkCmdNextSubpass(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdNextSubpass *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdNextSubpass_args_handle(args); - vkCmdNextSubpass(args->commandBuffer, args->contents); + vk->CmdNextSubpass(args->commandBuffer, args->contents); } static void vkr_dispatch_vkCmdEndRenderPass(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdEndRenderPass *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdEndRenderPass_args_handle(args); - vkCmdEndRenderPass(args->commandBuffer); + vk->CmdEndRenderPass(args->commandBuffer); } static void vkr_dispatch_vkCmdExecuteCommands(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdExecuteCommands *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdExecuteCommands_args_handle(args); - vkCmdExecuteCommands(args->commandBuffer, args->commandBufferCount, - args->pCommandBuffers); + vk->CmdExecuteCommands(args->commandBuffer, args->commandBufferCount, + args->pCommandBuffers); } static void vkr_dispatch_vkCmdSetDeviceMask(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdSetDeviceMask *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdSetDeviceMask_args_handle(args); - vkCmdSetDeviceMask(args->commandBuffer, args->deviceMask); + vk->CmdSetDeviceMask(args->commandBuffer, args->deviceMask); } static void vkr_dispatch_vkCmdDispatchBase(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkCmdDispatchBase *args) { + struct vkr_command_buffer *cmd = vkr_command_buffer_from_handle(args->commandBuffer); + struct vn_device_proc_table *vk = &cmd->device->proc_table; + vn_replace_vkCmdDispatchBase_args_handle(args); - vkCmdDispatchBase(args->commandBuffer, args->baseGroupX, args->baseGroupY, - args->baseGroupZ, args->groupCountX, args->groupCountY, - args->groupCountZ); + vk->CmdDispatchBase(args->commandBuffer, args->baseGroupX, args->baseGroupY, + args->baseGroupZ, args->groupCountX, args->groupCountY, + args->groupCountZ); } static void diff --git a/src/venus/vkr_context.c b/src/venus/vkr_context.c index 146100cc2..b5478130e 100644 --- a/src/venus/vkr_context.c +++ b/src/venus/vkr_context.c @@ -127,6 +127,7 @@ vkr_context_submit_fence_locked(struct virgl_context *base, void *fence_cookie) { struct vkr_context *ctx = (struct vkr_context *)base; + struct vn_device_proc_table *vk; struct vkr_queue *queue; VkResult result; @@ -134,13 +135,14 @@ vkr_context_submit_fence_locked(struct virgl_context *base, if (!queue) return -EINVAL; struct vkr_device *dev = queue->device; + vk = &dev->proc_table; struct vkr_queue_sync *sync = vkr_device_alloc_queue_sync(dev, flags, queue_id, fence_cookie); if (!sync) return -ENOMEM; - result = vkQueueSubmit(queue->base.handle.queue, 0, NULL, sync->fence); + result = vk->QueueSubmit(queue->base.handle.queue, 0, NULL, sync->fence); if (result == VK_ERROR_DEVICE_LOST) { sync->device_lost = true; } else if (result != VK_SUCCESS) { diff --git a/src/venus/vkr_descriptor_set.c b/src/venus/vkr_descriptor_set.c index efb0618b3..815764fa8 100644 --- a/src/venus/vkr_descriptor_set.c +++ b/src/venus/vkr_descriptor_set.c @@ -12,8 +12,11 @@ vkr_dispatch_vkGetDescriptorSetLayoutSupport( UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetDescriptorSetLayoutSupport *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetDescriptorSetLayoutSupport_args_handle(args); - vkGetDescriptorSetLayoutSupport(args->device, args->pCreateInfo, args->pSupport); + vk->GetDescriptorSetLayoutSupport(args->device, args->pCreateInfo, args->pSupport); } static void @@ -65,6 +68,9 @@ static void vkr_dispatch_vkResetDescriptorPool(struct vn_dispatch_context *dispatch, struct vn_command_vkResetDescriptorPool *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + struct vkr_context *ctx = dispatch->data; struct vkr_descriptor_pool *pool = @@ -75,7 +81,7 @@ vkr_dispatch_vkResetDescriptorPool(struct vn_dispatch_context *dispatch, } vn_replace_vkResetDescriptorPool_args_handle(args); - args->ret = vkResetDescriptorPool(args->device, args->descriptorPool, args->flags); + args->ret = vk->ResetDescriptorPool(args->device, args->descriptorPool, args->flags); vkr_descriptor_pool_release(ctx, pool); list_inithead(&pool->descriptor_sets); @@ -130,10 +136,13 @@ static void vkr_dispatch_vkUpdateDescriptorSets(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkUpdateDescriptorSets *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkUpdateDescriptorSets_args_handle(args); - vkUpdateDescriptorSets(args->device, args->descriptorWriteCount, - args->pDescriptorWrites, args->descriptorCopyCount, - args->pDescriptorCopies); + vk->UpdateDescriptorSets(args->device, args->descriptorWriteCount, + args->pDescriptorWrites, args->descriptorCopyCount, + args->pDescriptorCopies); } static void diff --git a/src/venus/vkr_device.c b/src/venus/vkr_device.c index c42a1608a..4cd4f93b9 100644 --- a/src/venus/vkr_device.c +++ b/src/venus/vkr_device.c @@ -20,6 +20,7 @@ vkr_device_create_queues(struct vkr_context *ctx, uint32_t create_info_count, const VkDeviceQueueCreateInfo *create_infos) { + struct vn_device_proc_table *vk = &dev->proc_table; list_inithead(&dev->queues); for (uint32_t i = 0; i < create_info_count; i++) { @@ -37,10 +38,10 @@ vkr_device_create_queues(struct vkr_context *ctx, * Work around drivers that are implementing this buggy behavior */ if (info.flags) { - vkGetDeviceQueue2(dev->base.handle.device, &info, &handle); + vk->GetDeviceQueue2(dev->base.handle.device, &info, &handle); } else { - vkGetDeviceQueue(dev->base.handle.device, info.queueFamilyIndex, - info.queueIndex, &handle); + vk->GetDeviceQueue(dev->base.handle.device, info.queueFamilyIndex, + info.queueIndex, &handle); } struct vkr_queue *queue = vkr_queue_create( @@ -156,81 +157,83 @@ vkr_device_object_destroy(struct vkr_context *ctx, struct vkr_device *dev, struct vkr_object *obj) { + struct vn_device_proc_table *vk = &dev->proc_table; VkDevice device = dev->base.handle.device; assert(vkr_device_should_track_object(obj)); switch (obj->type) { case VK_OBJECT_TYPE_SEMAPHORE: - vkDestroySemaphore(device, obj->handle.semaphore, NULL); + vk->DestroySemaphore(device, obj->handle.semaphore, NULL); break; case VK_OBJECT_TYPE_FENCE: - vkDestroyFence(device, obj->handle.fence, NULL); + vk->DestroyFence(device, obj->handle.fence, NULL); break; case VK_OBJECT_TYPE_DEVICE_MEMORY: - vkFreeMemory(device, obj->handle.device_memory, NULL); + vk->FreeMemory(device, obj->handle.device_memory, NULL); vkr_device_memory_release((struct vkr_device_memory *)obj); break; case VK_OBJECT_TYPE_BUFFER: - vkDestroyBuffer(device, obj->handle.buffer, NULL); + vk->DestroyBuffer(device, obj->handle.buffer, NULL); break; case VK_OBJECT_TYPE_IMAGE: - vkDestroyImage(device, obj->handle.image, NULL); + vk->DestroyImage(device, obj->handle.image, NULL); break; case VK_OBJECT_TYPE_EVENT: - vkDestroyEvent(device, obj->handle.event, NULL); + vk->DestroyEvent(device, obj->handle.event, NULL); break; case VK_OBJECT_TYPE_QUERY_POOL: - vkDestroyQueryPool(device, obj->handle.query_pool, NULL); + vk->DestroyQueryPool(device, obj->handle.query_pool, NULL); break; case VK_OBJECT_TYPE_BUFFER_VIEW: - vkDestroyBufferView(device, obj->handle.buffer_view, NULL); + vk->DestroyBufferView(device, obj->handle.buffer_view, NULL); break; case VK_OBJECT_TYPE_IMAGE_VIEW: - vkDestroyImageView(device, obj->handle.image_view, NULL); + vk->DestroyImageView(device, obj->handle.image_view, NULL); break; case VK_OBJECT_TYPE_SHADER_MODULE: - vkDestroyShaderModule(device, obj->handle.shader_module, NULL); + vk->DestroyShaderModule(device, obj->handle.shader_module, NULL); break; case VK_OBJECT_TYPE_PIPELINE_CACHE: - vkDestroyPipelineCache(device, obj->handle.pipeline_cache, NULL); + vk->DestroyPipelineCache(device, obj->handle.pipeline_cache, NULL); break; case VK_OBJECT_TYPE_PIPELINE_LAYOUT: - vkDestroyPipelineLayout(device, obj->handle.pipeline_layout, NULL); + vk->DestroyPipelineLayout(device, obj->handle.pipeline_layout, NULL); break; case VK_OBJECT_TYPE_RENDER_PASS: - vkDestroyRenderPass(device, obj->handle.render_pass, NULL); + vk->DestroyRenderPass(device, obj->handle.render_pass, NULL); break; case VK_OBJECT_TYPE_PIPELINE: - vkDestroyPipeline(device, obj->handle.pipeline, NULL); + vk->DestroyPipeline(device, obj->handle.pipeline, NULL); break; case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: - vkDestroyDescriptorSetLayout(device, obj->handle.descriptor_set_layout, NULL); + vk->DestroyDescriptorSetLayout(device, obj->handle.descriptor_set_layout, NULL); break; case VK_OBJECT_TYPE_SAMPLER: - vkDestroySampler(device, obj->handle.sampler, NULL); + vk->DestroySampler(device, obj->handle.sampler, NULL); break; case VK_OBJECT_TYPE_DESCRIPTOR_POOL: { /* Destroying VkDescriptorPool frees all VkDescriptorSet allocated inside. */ - vkDestroyDescriptorPool(device, obj->handle.descriptor_pool, NULL); + vk->DestroyDescriptorPool(device, obj->handle.descriptor_pool, NULL); vkr_descriptor_pool_release(ctx, (struct vkr_descriptor_pool *)obj); break; } case VK_OBJECT_TYPE_FRAMEBUFFER: - vkDestroyFramebuffer(device, obj->handle.framebuffer, NULL); + vk->DestroyFramebuffer(device, obj->handle.framebuffer, NULL); break; case VK_OBJECT_TYPE_COMMAND_POOL: { /* Destroying VkCommandPool frees all VkCommandBuffer allocated inside. */ - vkDestroyCommandPool(device, obj->handle.command_pool, NULL); + vk->DestroyCommandPool(device, obj->handle.command_pool, NULL); vkr_command_pool_release(ctx, (struct vkr_command_pool *)obj); break; } case VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION: - vkDestroySamplerYcbcrConversion(device, obj->handle.sampler_ycbcr_conversion, NULL); + vk->DestroySamplerYcbcrConversion(device, obj->handle.sampler_ycbcr_conversion, + NULL); break; case VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE: - vkDestroyDescriptorUpdateTemplate(device, obj->handle.descriptor_update_template, - NULL); + vk->DestroyDescriptorUpdateTemplate(device, obj->handle.descriptor_update_template, + NULL); break; default: vkr_log("Unhandled vkr_object(%p) with VkObjectType(%u)", obj, (uint32_t)obj->type); @@ -244,12 +247,13 @@ vkr_device_object_destroy(struct vkr_context *ctx, void vkr_device_destroy(struct vkr_context *ctx, struct vkr_device *dev) { + struct vn_device_proc_table *vk = &dev->proc_table; VkDevice device = dev->base.handle.device; if (!LIST_IS_EMPTY(&dev->objects)) vkr_log("destroying device with valid objects"); - VkResult result = vkDeviceWaitIdle(device); + VkResult result = vk->DeviceWaitIdle(device); if (result != VK_SUCCESS) vkr_log("vkDeviceWaitIdle(%p) failed(%d)", dev, (int32_t)result); @@ -265,13 +269,13 @@ vkr_device_destroy(struct vkr_context *ctx, struct vkr_device *dev) struct vkr_queue_sync *sync, *sync_tmp; LIST_FOR_EACH_ENTRY_SAFE (sync, sync_tmp, &dev->free_syncs, head) { - vkDestroyFence(dev->base.handle.device, sync->fence, NULL); + vk->DestroyFence(dev->base.handle.device, sync->fence, NULL); free(sync); } mtx_destroy(&dev->free_sync_mutex); - vkDestroyDevice(device, NULL); + vk->DestroyDevice(device, NULL); list_del(&dev->base.track_head); @@ -297,10 +301,13 @@ vkr_dispatch_vkGetDeviceGroupPeerMemoryFeatures( UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetDeviceGroupPeerMemoryFeatures *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetDeviceGroupPeerMemoryFeatures_args_handle(args); - vkGetDeviceGroupPeerMemoryFeatures(args->device, args->heapIndex, - args->localDeviceIndex, args->remoteDeviceIndex, - args->pPeerMemoryFeatures); + vk->GetDeviceGroupPeerMemoryFeatures(args->device, args->heapIndex, + args->localDeviceIndex, args->remoteDeviceIndex, + args->pPeerMemoryFeatures); } static void diff --git a/src/venus/vkr_device_memory.c b/src/venus/vkr_device_memory.c index 5e11a9a84..6378c52f9 100644 --- a/src/venus/vkr_device_memory.c +++ b/src/venus/vkr_device_memory.c @@ -246,8 +246,12 @@ vkr_dispatch_vkGetDeviceMemoryCommitment( UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetDeviceMemoryCommitment *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetDeviceMemoryCommitment_args_handle(args); - vkGetDeviceMemoryCommitment(args->device, args->memory, args->pCommittedMemoryInBytes); + vk->GetDeviceMemoryCommitment(args->device, args->memory, + args->pCommittedMemoryInBytes); } static void diff --git a/src/venus/vkr_image.c b/src/venus/vkr_image.c index 8df730809..b0e4b7e7a 100644 --- a/src/venus/vkr_image.c +++ b/src/venus/vkr_image.c @@ -46,8 +46,11 @@ vkr_dispatch_vkGetImageMemoryRequirements( UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetImageMemoryRequirements *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetImageMemoryRequirements_args_handle(args); - vkGetImageMemoryRequirements(args->device, args->image, args->pMemoryRequirements); + vk->GetImageMemoryRequirements(args->device, args->image, args->pMemoryRequirements); } static void @@ -55,8 +58,11 @@ vkr_dispatch_vkGetImageMemoryRequirements2( UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetImageMemoryRequirements2 *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetImageMemoryRequirements2_args_handle(args); - vkGetImageMemoryRequirements2(args->device, args->pInfo, args->pMemoryRequirements); + vk->GetImageMemoryRequirements2(args->device, args->pInfo, args->pMemoryRequirements); } static void @@ -64,10 +70,13 @@ vkr_dispatch_vkGetImageSparseMemoryRequirements( UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetImageSparseMemoryRequirements *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetImageSparseMemoryRequirements_args_handle(args); - vkGetImageSparseMemoryRequirements(args->device, args->image, - args->pSparseMemoryRequirementCount, - args->pSparseMemoryRequirements); + vk->GetImageSparseMemoryRequirements(args->device, args->image, + args->pSparseMemoryRequirementCount, + args->pSparseMemoryRequirements); } static void @@ -75,27 +84,36 @@ vkr_dispatch_vkGetImageSparseMemoryRequirements2( UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetImageSparseMemoryRequirements2 *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetImageSparseMemoryRequirements2_args_handle(args); - vkGetImageSparseMemoryRequirements2(args->device, args->pInfo, - args->pSparseMemoryRequirementCount, - args->pSparseMemoryRequirements); + vk->GetImageSparseMemoryRequirements2(args->device, args->pInfo, + args->pSparseMemoryRequirementCount, + args->pSparseMemoryRequirements); } static void vkr_dispatch_vkBindImageMemory(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkBindImageMemory *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkBindImageMemory_args_handle(args); args->ret = - vkBindImageMemory(args->device, args->image, args->memory, args->memoryOffset); + vk->BindImageMemory(args->device, args->image, args->memory, args->memoryOffset); } static void vkr_dispatch_vkBindImageMemory2(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkBindImageMemory2 *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkBindImageMemory2_args_handle(args); - args->ret = vkBindImageMemory2(args->device, args->bindInfoCount, args->pBindInfos); + args->ret = vk->BindImageMemory2(args->device, args->bindInfoCount, args->pBindInfos); } static void @@ -103,9 +121,12 @@ vkr_dispatch_vkGetImageSubresourceLayout( UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetImageSubresourceLayout *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetImageSubresourceLayout_args_handle(args); - vkGetImageSubresourceLayout(args->device, args->image, args->pSubresource, - args->pLayout); + vk->GetImageSubresourceLayout(args->device, args->image, args->pSubresource, + args->pLayout); } static void diff --git a/src/venus/vkr_pipeline.c b/src/venus/vkr_pipeline.c index d30756ea3..8fd1b0596 100644 --- a/src/venus/vkr_pipeline.c +++ b/src/venus/vkr_pipeline.c @@ -53,18 +53,24 @@ static void vkr_dispatch_vkGetPipelineCacheData(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetPipelineCacheData *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetPipelineCacheData_args_handle(args); - args->ret = vkGetPipelineCacheData(args->device, args->pipelineCache, args->pDataSize, - args->pData); + args->ret = vk->GetPipelineCacheData(args->device, args->pipelineCache, + args->pDataSize, args->pData); } static void vkr_dispatch_vkMergePipelineCaches(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkMergePipelineCaches *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkMergePipelineCaches_args_handle(args); - args->ret = vkMergePipelineCaches(args->device, args->dstCache, args->srcCacheCount, - args->pSrcCaches); + args->ret = vk->MergePipelineCaches(args->device, args->dstCache, args->srcCacheCount, + args->pSrcCaches); } static void diff --git a/src/venus/vkr_query_pool.c b/src/venus/vkr_query_pool.c index 8f10fccf4..eb77fe4d7 100644 --- a/src/venus/vkr_query_pool.c +++ b/src/venus/vkr_query_pool.c @@ -25,10 +25,13 @@ static void vkr_dispatch_vkGetQueryPoolResults(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetQueryPoolResults *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetQueryPoolResults_args_handle(args); - args->ret = vkGetQueryPoolResults(args->device, args->queryPool, args->firstQuery, - args->queryCount, args->dataSize, args->pData, - args->stride, args->flags); + args->ret = vk->GetQueryPoolResults(args->device, args->queryPool, args->firstQuery, + args->queryCount, args->dataSize, args->pData, + args->stride, args->flags); } static void diff --git a/src/venus/vkr_queue.c b/src/venus/vkr_queue.c index 4425c754b..9309d7bfd 100644 --- a/src/venus/vkr_queue.c +++ b/src/venus/vkr_queue.c @@ -16,6 +16,7 @@ vkr_device_alloc_queue_sync(struct vkr_device *dev, uint64_t queue_id, void *fence_cookie) { + struct vn_device_proc_table *vk = &dev->proc_table; struct vkr_queue_sync *sync; if (vkr_renderer_flags & VKR_RENDERER_ASYNC_FENCE_CB) @@ -38,7 +39,7 @@ vkr_device_alloc_queue_sync(struct vkr_device *dev, .pNext = dev->physical_device->KHR_external_fence_fd ? &export_info : NULL, }; VkResult result = - vkCreateFence(dev->base.handle.device, &create_info, NULL, &sync->fence); + vk->CreateFence(dev->base.handle.device, &create_info, NULL, &sync->fence); if (result != VK_SUCCESS) { free(sync); return NULL; @@ -50,7 +51,7 @@ vkr_device_alloc_queue_sync(struct vkr_device *dev, if (vkr_renderer_flags & VKR_RENDERER_ASYNC_FENCE_CB) mtx_unlock(&dev->free_sync_mutex); - vkResetFences(dev->base.handle.device, 1, &sync->fence); + vk->ResetFences(dev->base.handle.device, 1, &sync->fence); } sync->device_lost = false; @@ -79,6 +80,7 @@ vkr_queue_get_signaled_syncs(struct vkr_queue *queue, bool *queue_empty) { struct vkr_device *dev = queue->device; + struct vn_device_proc_table *vk = &dev->proc_table; struct vkr_queue_sync *sync, *tmp; assert(!(vkr_renderer_flags & VKR_RENDERER_ASYNC_FENCE_CB)); @@ -103,7 +105,7 @@ vkr_queue_get_signaled_syncs(struct vkr_queue *queue, } else { LIST_FOR_EACH_ENTRY_SAFE (sync, tmp, &queue->pending_syncs, head) { if (!sync->device_lost) { - VkResult result = vkGetFenceStatus(dev->base.handle.device, sync->fence); + VkResult result = vk->GetFenceStatus(dev->base.handle.device, sync->fence); if (result == VK_NOT_READY) break; } @@ -126,11 +128,13 @@ vkr_queue_sync_retire(struct vkr_context *ctx, struct vkr_device *dev, struct vkr_queue_sync *sync) { + struct vn_device_proc_table *vk = &dev->proc_table; + if (vkr_renderer_flags & VKR_RENDERER_ASYNC_FENCE_CB) { ctx->base.fence_retire(&ctx->base, sync->queue_id, sync->fence_cookie); vkr_device_free_queue_sync(dev, sync); } else { - vkDestroyFence(dev->base.handle.device, sync->fence, NULL); + vk->DestroyFence(dev->base.handle.device, sync->fence, NULL); sync->fence = VK_NULL_HANDLE; /* move to the ctx to be retired and freed at the next retire_fences */ @@ -185,6 +189,7 @@ vkr_queue_thread(void *arg) struct vkr_queue *queue = arg; struct vkr_context *ctx = queue->context; struct vkr_device *dev = queue->device; + struct vn_device_proc_table *vk = &dev->proc_table; const uint64_t ns_per_sec = 1000000000llu; char thread_name[16]; @@ -208,8 +213,8 @@ vkr_queue_thread(void *arg) if (sync->device_lost) { result = VK_ERROR_DEVICE_LOST; } else { - result = vkWaitForFences(dev->base.handle.device, 1, &sync->fence, true, - ns_per_sec * 3); + result = vk->WaitForFences(dev->base.handle.device, 1, &sync->fence, true, + ns_per_sec * 3); } mtx_lock(&queue->mutex); @@ -367,17 +372,24 @@ static void vkr_dispatch_vkQueueSubmit(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkQueueSubmit *args) { + struct vkr_queue *queue = vkr_queue_from_handle(args->queue); + struct vn_device_proc_table *vk = &queue->device->proc_table; + vn_replace_vkQueueSubmit_args_handle(args); - args->ret = vkQueueSubmit(args->queue, args->submitCount, args->pSubmits, args->fence); + args->ret = + vk->QueueSubmit(args->queue, args->submitCount, args->pSubmits, args->fence); } static void vkr_dispatch_vkQueueBindSparse(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkQueueBindSparse *args) { + struct vkr_queue *queue = vkr_queue_from_handle(args->queue); + struct vn_device_proc_table *vk = &queue->device->proc_table; + vn_replace_vkQueueBindSparse_args_handle(args); args->ret = - vkQueueBindSparse(args->queue, args->bindInfoCount, args->pBindInfo, args->fence); + vk->QueueBindSparse(args->queue, args->bindInfoCount, args->pBindInfo, args->fence); } static void @@ -407,16 +419,22 @@ static void vkr_dispatch_vkResetFences(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkResetFences *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkResetFences_args_handle(args); - args->ret = vkResetFences(args->device, args->fenceCount, args->pFences); + args->ret = vk->ResetFences(args->device, args->fenceCount, args->pFences); } static void vkr_dispatch_vkGetFenceStatus(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetFenceStatus *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetFenceStatus_args_handle(args); - args->ret = vkGetFenceStatus(args->device, args->fence); + args->ret = vk->GetFenceStatus(args->device, args->fence); } static void @@ -424,6 +442,8 @@ vkr_dispatch_vkWaitForFences(struct vn_dispatch_context *dispatch, struct vn_command_vkWaitForFences *args) { struct vkr_context *ctx = dispatch->data; + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; /* Being single-threaded, we cannot afford potential blocking calls. It * also leads to GPU lost when the wait never returns and can only be @@ -436,8 +456,8 @@ vkr_dispatch_vkWaitForFences(struct vn_dispatch_context *dispatch, } vn_replace_vkWaitForFences_args_handle(args); - args->ret = vkWaitForFences(args->device, args->fenceCount, args->pFences, - args->waitAll, args->timeout); + args->ret = vk->WaitForFences(args->device, args->fenceCount, args->pFences, + args->waitAll, args->timeout); } static void @@ -512,24 +532,33 @@ static void vkr_dispatch_vkGetEventStatus(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetEventStatus *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetEventStatus_args_handle(args); - args->ret = vkGetEventStatus(args->device, args->event); + args->ret = vk->GetEventStatus(args->device, args->event); } static void vkr_dispatch_vkSetEvent(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkSetEvent *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkSetEvent_args_handle(args); - args->ret = vkSetEvent(args->device, args->event); + args->ret = vk->SetEvent(args->device, args->event); } static void vkr_dispatch_vkResetEvent(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkResetEvent *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkResetEvent_args_handle(args); - args->ret = vkResetEvent(args->device, args->event); + args->ret = vk->ResetEvent(args->device, args->event); } void diff --git a/src/venus/vkr_render_pass.c b/src/venus/vkr_render_pass.c index 1aa44bd75..4d8c59ef0 100644 --- a/src/venus/vkr_render_pass.c +++ b/src/venus/vkr_render_pass.c @@ -51,8 +51,11 @@ static void vkr_dispatch_vkGetRenderAreaGranularity(UNUSED struct vn_dispatch_context *dispatch, struct vn_command_vkGetRenderAreaGranularity *args) { + struct vkr_device *dev = vkr_device_from_handle(args->device); + struct vn_device_proc_table *vk = &dev->proc_table; + vn_replace_vkGetRenderAreaGranularity_args_handle(args); - vkGetRenderAreaGranularity(args->device, args->renderPass, args->pGranularity); + vk->GetRenderAreaGranularity(args->device, args->renderPass, args->pGranularity); } static void -- GitLab