From 125cee09ef9ce6c73272e3eb14f0e88a3a21e9de Mon Sep 17 00:00:00 2001 From: baldurk Date: Tue, 15 Oct 2019 12:51:11 +0100 Subject: [PATCH] Add support for VK_KHR_timeline_semaphore --- renderdoc/driver/vulkan/vk_common.h | 15 ++ renderdoc/driver/vulkan/vk_core.cpp | 3 + renderdoc/driver/vulkan/vk_core.h | 11 ++ renderdoc/driver/vulkan/vk_hookset_defs.h | 15 +- renderdoc/driver/vulkan/vk_serialise.cpp | 128 ++++++++++++++- renderdoc/driver/vulkan/vk_stringise.cpp | 5 +- .../vulkan/wrappers/vk_device_funcs.cpp | 7 + .../driver/vulkan/wrappers/vk_queue_funcs.cpp | 2 +- .../driver/vulkan/wrappers/vk_sync_funcs.cpp | 149 ++++++++++++++++++ 9 files changed, 323 insertions(+), 12 deletions(-) diff --git a/renderdoc/driver/vulkan/vk_common.h b/renderdoc/driver/vulkan/vk_common.h index aa12bb383..047e9a8e4 100644 --- a/renderdoc/driver/vulkan/vk_common.h +++ b/renderdoc/driver/vulkan/vk_common.h @@ -587,6 +587,9 @@ enum class VulkanChunk : uint32_t vkResetQueryPoolEXT, ImageRefs, vkCmdSetLineStippleEXT, + vkGetSemaphoreCounterValueKHR, + vkWaitSemaphoresKHR, + vkSignalSemaphoreKHR, Max, }; @@ -818,6 +821,8 @@ DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceSurfaceInfo2KHR); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT); +DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceTimelineSemaphoreFeaturesKHR); +DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceTimelineSemaphorePropertiesKHR); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceTransformFeedbackFeaturesEXT); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceTransformFeedbackPropertiesEXT); DECLARE_REFLECTION_STRUCT(VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR); @@ -877,6 +882,9 @@ DECLARE_REFLECTION_STRUCT(VkSamplerYcbcrConversionImageFormatProperties); DECLARE_REFLECTION_STRUCT(VkSamplerYcbcrConversionInfo); DECLARE_REFLECTION_STRUCT(VkSemaphoreCreateInfo); DECLARE_REFLECTION_STRUCT(VkSemaphoreGetFdInfoKHR); +DECLARE_REFLECTION_STRUCT(VkSemaphoreSignalInfoKHR); +DECLARE_REFLECTION_STRUCT(VkSemaphoreTypeCreateInfoKHR); +DECLARE_REFLECTION_STRUCT(VkSemaphoreWaitInfoKHR); DECLARE_REFLECTION_STRUCT(VkShaderModuleCreateInfo); DECLARE_REFLECTION_STRUCT(VkShaderModuleValidationCacheCreateInfoEXT); DECLARE_REFLECTION_STRUCT(VkSharedPresentSurfaceCapabilitiesKHR); @@ -897,6 +905,7 @@ DECLARE_REFLECTION_STRUCT(VkSwapchainCounterCreateInfoEXT); DECLARE_REFLECTION_STRUCT(VkSwapchainCreateInfoKHR); DECLARE_REFLECTION_STRUCT(VkSwapchainDisplayNativeHdrCreateInfoAMD); DECLARE_REFLECTION_STRUCT(VkTextureLODGatherFormatPropertiesAMD); +DECLARE_REFLECTION_STRUCT(VkTimelineSemaphoreSubmitInfoKHR); DECLARE_REFLECTION_STRUCT(VkValidationCacheCreateInfoEXT); DECLARE_REFLECTION_STRUCT(VkValidationFeaturesEXT); DECLARE_REFLECTION_STRUCT(VkValidationFlagsEXT); @@ -1081,6 +1090,8 @@ DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceSurfaceInfo2KHR); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT); +DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTimelineSemaphoreFeaturesKHR); +DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTimelineSemaphorePropertiesKHR); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTransformFeedbackFeaturesEXT); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceTransformFeedbackPropertiesEXT); DECLARE_DESERIALISE_TYPE(VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR); @@ -1137,6 +1148,9 @@ DECLARE_DESERIALISE_TYPE(VkSamplerYcbcrConversionImageFormatProperties); DECLARE_DESERIALISE_TYPE(VkSamplerYcbcrConversionInfo); DECLARE_DESERIALISE_TYPE(VkSemaphoreCreateInfo); DECLARE_DESERIALISE_TYPE(VkSemaphoreGetFdInfoKHR); +DECLARE_DESERIALISE_TYPE(VkSemaphoreSignalInfoKHR); +DECLARE_DESERIALISE_TYPE(VkSemaphoreTypeCreateInfoKHR); +DECLARE_DESERIALISE_TYPE(VkSemaphoreWaitInfoKHR); DECLARE_DESERIALISE_TYPE(VkShaderModuleCreateInfo); DECLARE_DESERIALISE_TYPE(VkShaderModuleValidationCacheCreateInfoEXT); DECLARE_DESERIALISE_TYPE(VkSharedPresentSurfaceCapabilitiesKHR); @@ -1157,6 +1171,7 @@ DECLARE_DESERIALISE_TYPE(VkSwapchainCounterCreateInfoEXT); DECLARE_DESERIALISE_TYPE(VkSwapchainCreateInfoKHR); DECLARE_DESERIALISE_TYPE(VkSwapchainDisplayNativeHdrCreateInfoAMD); DECLARE_DESERIALISE_TYPE(VkTextureLODGatherFormatPropertiesAMD); +DECLARE_DESERIALISE_TYPE(VkTimelineSemaphoreSubmitInfoKHR); DECLARE_DESERIALISE_TYPE(VkValidationCacheCreateInfoEXT); DECLARE_DESERIALISE_TYPE(VkValidationFeaturesEXT); DECLARE_DESERIALISE_TYPE(VkValidationFlagsEXT); diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index edda1abc4..9e0bf5679 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -1017,6 +1017,9 @@ static const VkExtensionProperties supportedExtensions[] = { { VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME, VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION, }, + { + VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME, VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION, + }, { VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION, diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index b3be934f6..16a803ec3 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -2181,4 +2181,15 @@ public: const VkMetalSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface); #endif + + // VK_KHR_timeline_semaphore + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetSemaphoreCounterValueKHR, VkDevice device, + VkSemaphore semaphore, uint64_t *pValue); + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkWaitSemaphoresKHR, VkDevice device, + const VkSemaphoreWaitInfoKHR *pWaitInfo, uint64_t timeout); + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkSignalSemaphoreKHR, VkDevice device, + const VkSemaphoreSignalInfoKHR *pSignalInfo); }; diff --git a/renderdoc/driver/vulkan/vk_hookset_defs.h b/renderdoc/driver/vulkan/vk_hookset_defs.h index 5805e1796..c57810267 100644 --- a/renderdoc/driver/vulkan/vk_hookset_defs.h +++ b/renderdoc/driver/vulkan/vk_hookset_defs.h @@ -451,7 +451,8 @@ DeclExt(KHR_pipeline_executable_properties); \ DeclExt(AMD_negative_viewport_height); \ DeclExt(EXT_line_rasterization); \ - DeclExt(GOOGLE_display_timing); + DeclExt(GOOGLE_display_timing); \ + DeclExt(KHR_timeline_semaphore); // for simplicity and since the check itself is platform agnostic, // these aren't protected in platform defines @@ -536,7 +537,8 @@ CheckExt(KHR_pipeline_executable_properties, VKXX); \ CheckExt(AMD_negative_viewport_height, VKXX); \ CheckExt(EXT_line_rasterization, VKXX); \ - CheckExt(GOOGLE_display_timing, VKXX); + CheckExt(GOOGLE_display_timing, VKXX); \ + CheckExt(KHR_timeline_semaphore, VKXX); #define HookInitVulkanInstanceExts() \ HookInitExtension(KHR_surface, DestroySurfaceKHR); \ @@ -682,6 +684,9 @@ HookInitExtension(EXT_line_rasterization, CmdSetLineStippleEXT); \ HookInitExtension(GOOGLE_display_timing, GetRefreshCycleDurationGOOGLE); \ HookInitExtension(GOOGLE_display_timing, GetPastPresentationTimingGOOGLE); \ + HookInitExtension(KHR_timeline_semaphore, GetSemaphoreCounterValueKHR); \ + HookInitExtension(KHR_timeline_semaphore, WaitSemaphoresKHR); \ + HookInitExtension(KHR_timeline_semaphore, SignalSemaphoreKHR); \ HookInitDevice_PlatformSpecific() #define DefineHooks() \ @@ -1278,4 +1283,10 @@ HookDefine4(VkResult, vkGetPastPresentationTimingGOOGLE, VkDevice, device, VkSwapchainKHR, \ swapchain, uint32_t *, pPresentationTimingCount, VkPastPresentationTimingGOOGLE *, \ pPresentationTimings); \ + HookDefine3(VkResult, vkGetSemaphoreCounterValueKHR, VkDevice, device, VkSemaphore, semaphore, \ + uint64_t *, pValue); \ + HookDefine3(VkResult, vkWaitSemaphoresKHR, VkDevice, device, const VkSemaphoreWaitInfoKHR *, \ + pWaitInfo, uint64_t, timeout); \ + HookDefine2(VkResult, vkSignalSemaphoreKHR, VkDevice, device, const VkSemaphoreSignalInfoKHR *, \ + pSignalInfo); \ HookDefine_PlatformSpecific() diff --git a/renderdoc/driver/vulkan/vk_serialise.cpp b/renderdoc/driver/vulkan/vk_serialise.cpp index c000e0bf8..eb89d53c0 100644 --- a/renderdoc/driver/vulkan/vk_serialise.cpp +++ b/renderdoc/driver/vulkan/vk_serialise.cpp @@ -891,6 +891,17 @@ SERIALISE_VK_HANDLES(); PNEXT_STRUCT(VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, VkPresentInfoKHR) \ PNEXT_STRUCT(VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR, VkAcquireNextImageInfoKHR) \ \ + /* VK_KHR_timeline_semaphore */ \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR, \ + VkPhysicalDeviceTimelineSemaphoreFeaturesKHR) \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR, \ + VkPhysicalDeviceTimelineSemaphorePropertiesKHR) \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR, VkSemaphoreTypeCreateInfoKHR) \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR, \ + VkTimelineSemaphoreSubmitInfoKHR) \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR, VkSemaphoreWaitInfoKHR) \ + PNEXT_STRUCT(VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR, VkSemaphoreSignalInfoKHR) \ + \ /* VK_KHR_uniform_buffer_standard_layout */ \ PNEXT_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR, \ VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR) \ @@ -991,14 +1002,6 @@ SERIALISE_VK_HANDLES(); /* VK_EXT_texture_compression_astc_hdr */ \ PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT) \ \ - /* VK_KHR_timeline_semaphore */ \ - PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR) \ - PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR) \ - PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR) \ - PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR) \ - PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR) \ - PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR) \ - \ /* VK_INTEL_performance_query */ \ PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL) \ PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL) \ @@ -3438,6 +3441,109 @@ void Deserialise(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &el) DeserialiseNext(el.pNext); } +template +void DoSerialise(SerialiserType &ser, VkPhysicalDeviceTimelineSemaphoreFeaturesKHR &el) +{ + RDCASSERT(ser.IsReading() || + el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(timelineSemaphore); +} + +template <> +void Deserialise(const VkPhysicalDeviceTimelineSemaphoreFeaturesKHR &el) +{ + DeserialiseNext(el.pNext); +} + +template +void DoSerialise(SerialiserType &ser, VkPhysicalDeviceTimelineSemaphorePropertiesKHR &el) +{ + RDCASSERT(ser.IsReading() || + el.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(maxTimelineSemaphoreValueDifference); +} + +template <> +void Deserialise(const VkPhysicalDeviceTimelineSemaphorePropertiesKHR &el) +{ + DeserialiseNext(el.pNext); +} + +template +void DoSerialise(SerialiserType &ser, VkSemaphoreTypeCreateInfoKHR &el) +{ + RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(semaphoreType); + SERIALISE_MEMBER(initialValue); +} + +template <> +void Deserialise(const VkSemaphoreTypeCreateInfoKHR &el) +{ + DeserialiseNext(el.pNext); +} + +template +void DoSerialise(SerialiserType &ser, VkTimelineSemaphoreSubmitInfoKHR &el) +{ + RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(waitSemaphoreValueCount); + SERIALISE_MEMBER_ARRAY(pWaitSemaphoreValues, waitSemaphoreValueCount); + SERIALISE_MEMBER(signalSemaphoreValueCount); + SERIALISE_MEMBER_ARRAY(pSignalSemaphoreValues, signalSemaphoreValueCount); +} + +template <> +void Deserialise(const VkTimelineSemaphoreSubmitInfoKHR &el) +{ + DeserialiseNext(el.pNext); + delete[] el.pWaitSemaphoreValues; + delete[] el.pSignalSemaphoreValues; +} + +template +void DoSerialise(SerialiserType &ser, VkSemaphoreWaitInfoKHR &el) +{ + RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(semaphoreCount); + SERIALISE_MEMBER_ARRAY(pSemaphores, semaphoreCount); + SERIALISE_MEMBER_ARRAY(pValues, semaphoreCount); +} + +template <> +void Deserialise(const VkSemaphoreWaitInfoKHR &el) +{ + DeserialiseNext(el.pNext); + delete[] el.pSemaphores; + delete[] el.pValues; +} + +template +void DoSerialise(SerialiserType &ser, VkSemaphoreSignalInfoKHR &el) +{ + RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR); + SerialiseNext(ser, el.sType, el.pNext); + + SERIALISE_MEMBER(semaphore); + SERIALISE_MEMBER(value); +} + +template <> +void Deserialise(const VkSemaphoreSignalInfoKHR &el) +{ + DeserialiseNext(el.pNext); +} + template void DoSerialise(SerialiserType &ser, VkDebugMarkerMarkerInfoEXT &el) { @@ -7577,6 +7683,8 @@ INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceSurfaceInfo2KHR); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT); +INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceTimelineSemaphoreFeaturesKHR); +INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceTimelineSemaphorePropertiesKHR); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceTransformFeedbackFeaturesEXT); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceTransformFeedbackPropertiesEXT); INSTANTIATE_SERIALISE_TYPE(VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR); @@ -7636,6 +7744,9 @@ INSTANTIATE_SERIALISE_TYPE(VkSamplerYcbcrConversionImageFormatProperties); INSTANTIATE_SERIALISE_TYPE(VkSamplerYcbcrConversionInfo); INSTANTIATE_SERIALISE_TYPE(VkSemaphoreCreateInfo); INSTANTIATE_SERIALISE_TYPE(VkSemaphoreGetFdInfoKHR); +INSTANTIATE_SERIALISE_TYPE(VkSemaphoreSignalInfoKHR); +INSTANTIATE_SERIALISE_TYPE(VkSemaphoreTypeCreateInfoKHR); +INSTANTIATE_SERIALISE_TYPE(VkSemaphoreWaitInfoKHR); INSTANTIATE_SERIALISE_TYPE(VkShaderModuleCreateInfo); INSTANTIATE_SERIALISE_TYPE(VkShaderModuleValidationCacheCreateInfoEXT); INSTANTIATE_SERIALISE_TYPE(VkSharedPresentSurfaceCapabilitiesKHR); @@ -7656,6 +7767,7 @@ INSTANTIATE_SERIALISE_TYPE(VkSwapchainCounterCreateInfoEXT); INSTANTIATE_SERIALISE_TYPE(VkSwapchainCreateInfoKHR); INSTANTIATE_SERIALISE_TYPE(VkSwapchainDisplayNativeHdrCreateInfoAMD); INSTANTIATE_SERIALISE_TYPE(VkTextureLODGatherFormatPropertiesAMD); +INSTANTIATE_SERIALISE_TYPE(VkTimelineSemaphoreSubmitInfoKHR); INSTANTIATE_SERIALISE_TYPE(VkValidationCacheCreateInfoEXT); INSTANTIATE_SERIALISE_TYPE(VkValidationFeaturesEXT); INSTANTIATE_SERIALISE_TYPE(VkValidationFlagsEXT); diff --git a/renderdoc/driver/vulkan/vk_stringise.cpp b/renderdoc/driver/vulkan/vk_stringise.cpp index 86c11bb19..2962b387f 100644 --- a/renderdoc/driver/vulkan/vk_stringise.cpp +++ b/renderdoc/driver/vulkan/vk_stringise.cpp @@ -28,7 +28,7 @@ template <> rdcstr DoStringise(const VulkanChunk &el) { - RDCCOMPILE_ASSERT((uint32_t)VulkanChunk::Max == 1136, "Chunks changed without updating names"); + RDCCOMPILE_ASSERT((uint32_t)VulkanChunk::Max == 1139, "Chunks changed without updating names"); BEGIN_ENUM_STRINGISE(VulkanChunk) { @@ -168,6 +168,9 @@ rdcstr DoStringise(const VulkanChunk &el) STRINGISE_ENUM_CLASS(vkResetQueryPoolEXT); STRINGISE_ENUM_CLASS_NAMED(ImageRefs, "Image References") STRINGISE_ENUM_CLASS(vkCmdSetLineStippleEXT); + STRINGISE_ENUM_CLASS(vkGetSemaphoreCounterValueKHR); + STRINGISE_ENUM_CLASS(vkWaitSemaphoresKHR); + STRINGISE_ENUM_CLASS(vkSignalSemaphoreKHR); STRINGISE_ENUM_CLASS_NAMED(Max, "Max Chunk"); } END_ENUM_STRINGISE() diff --git a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp index 777a285f1..8830b7120 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp @@ -2322,6 +2322,13 @@ bool WrappedVulkan::Serialise_vkCreateDevice(SerialiserType &ser, VkPhysicalDevi CHECK_PHYS_EXT_FEATURE(shaderInt8); } END_PHYS_EXT_CHECK(); + + BEGIN_PHYS_EXT_CHECK(VkPhysicalDeviceTimelineSemaphoreFeaturesKHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR); + { + CHECK_PHYS_EXT_FEATURE(timelineSemaphore); + } + END_PHYS_EXT_CHECK(); } if(availFeatures.depthClamp) diff --git a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp index 1e6943a59..70c8bad6c 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp @@ -1653,4 +1653,4 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkQueueInsertDebugUtilsLabelEXT, VkQueue q const VkDebugUtilsLabelEXT *pLabelInfo); INSTANTIATE_FUNCTION_SERIALISED(void, vkGetDeviceQueue2, VkDevice device, - const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue); + const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue); \ No newline at end of file diff --git a/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp index 2d180b1ab..1f9cbcf1b 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_sync_funcs.cpp @@ -937,6 +937,146 @@ VkResult WrappedVulkan::vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoK return ObjDisp(device)->GetFenceFdKHR(Unwrap(device), &unwrappedInfo, pFd); } +template +bool WrappedVulkan::Serialise_vkGetSemaphoreCounterValueKHR(SerialiserType &ser, VkDevice device, + VkSemaphore semaphore, uint64_t *pValue) +{ + SERIALISE_ELEMENT(device); + SERIALISE_ELEMENT(semaphore); + SERIALISE_ELEMENT_OPT(pValue); + + Serialise_DebugMessages(ser); + + SERIALISE_CHECK_READ_ERRORS(); + + if(IsReplayingAndReading()) + { + ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); + } + + return true; +} + +VkResult WrappedVulkan::vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, + uint64_t *pValue) +{ + SCOPED_DBG_SINK(); + + VkResult ret; + SERIALISE_TIME_CALL(ret = ObjDisp(device)->GetSemaphoreCounterValueKHR( + Unwrap(device), Unwrap(semaphore), pValue)); + + if(IsActiveCapturing(m_State)) + { + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkGetSemaphoreCounterValueKHR); + Serialise_vkGetSemaphoreCounterValueKHR(ser, device, semaphore, pValue); + + m_FrameCaptureRecord->AddChunk(scope.Get()); + GetResourceManager()->MarkResourceFrameReferenced(GetResID(semaphore), eFrameRef_Read); + } + + return ret; +} + +template +bool WrappedVulkan::Serialise_vkWaitSemaphoresKHR(SerialiserType &ser, VkDevice device, + const VkSemaphoreWaitInfoKHR *pWaitInfo, + uint64_t timeout) +{ + SERIALISE_ELEMENT(device); + SERIALISE_ELEMENT_LOCAL(WaitInfo, *pWaitInfo); + SERIALISE_ELEMENT(timeout); + + Serialise_DebugMessages(ser); + + SERIALISE_CHECK_READ_ERRORS(); + + if(IsReplayingAndReading()) + { + ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); + } + + return true; +} + +VkResult WrappedVulkan::vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfoKHR *pWaitInfo, + uint64_t timeout) +{ + SCOPED_DBG_SINK(); + + VkSemaphore *unwrappedSems = GetTempArray(pWaitInfo->semaphoreCount); + for(uint32_t i = 0; i < pWaitInfo->semaphoreCount; i++) + unwrappedSems[i] = Unwrap(pWaitInfo->pSemaphores[i]); + + VkSemaphoreWaitInfoKHR unwrapped = *pWaitInfo; + unwrapped.pSemaphores = unwrappedSems; + + VkResult ret; + SERIALISE_TIME_CALL(ret = ObjDisp(device)->WaitSemaphoresKHR(Unwrap(device), &unwrapped, timeout)); + + if(IsActiveCapturing(m_State)) + { + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkWaitSemaphoresKHR); + Serialise_vkWaitSemaphoresKHR(ser, device, pWaitInfo, timeout); + + m_FrameCaptureRecord->AddChunk(scope.Get()); + for(uint32_t i = 0; i < pWaitInfo->semaphoreCount; i++) + GetResourceManager()->MarkResourceFrameReferenced(GetResID(pWaitInfo->pSemaphores[i]), + eFrameRef_Read); + } + + return ret; +} + +template +bool WrappedVulkan::Serialise_vkSignalSemaphoreKHR(SerialiserType &ser, VkDevice device, + const VkSemaphoreSignalInfoKHR *pSignalInfo) +{ + SERIALISE_ELEMENT(device); + SERIALISE_ELEMENT_LOCAL(SignalInfo, *pSignalInfo); + + Serialise_DebugMessages(ser); + + SERIALISE_CHECK_READ_ERRORS(); + + if(IsReplayingAndReading()) + { + ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); + } + + return true; +} + +VkResult WrappedVulkan::vkSignalSemaphoreKHR(VkDevice device, + const VkSemaphoreSignalInfoKHR *pSignalInfo) +{ + VkSemaphoreSignalInfoKHR unwrapped = *pSignalInfo; + unwrapped.semaphore = Unwrap(unwrapped.semaphore); + + SCOPED_DBG_SINK(); + + VkResult ret; + SERIALISE_TIME_CALL(ret = ObjDisp(device)->SignalSemaphoreKHR(Unwrap(device), &unwrapped)); + + if(IsActiveCapturing(m_State)) + { + CACHE_THREAD_SERIALISER(); + + SCOPED_SERIALISE_CHUNK(VulkanChunk::vkSignalSemaphoreKHR); + Serialise_vkSignalSemaphoreKHR(ser, device, pSignalInfo); + + m_FrameCaptureRecord->AddChunk(scope.Get()); + GetResourceManager()->MarkResourceFrameReferenced(GetResID(pSignalInfo->semaphore), + eFrameRef_Read); + } + + return ret; +} + #if defined(VK_USE_PLATFORM_WIN32_KHR) VkResult WrappedVulkan::vkImportSemaphoreWin32HandleKHR( @@ -1015,3 +1155,12 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdWaitEvents, VkCommandBuffer commandBu const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkGetSemaphoreCounterValueKHR, VkDevice device, + VkSemaphore semaphore, uint64_t *pValue); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkWaitSemaphoresKHR, VkDevice device, + const VkSemaphoreWaitInfoKHR *pWaitInfo, uint64_t timeout); + +INSTANTIATE_FUNCTION_SERIALISED(void, vkSignalSemaphoreKHR, VkDevice device, + const VkSemaphoreSignalInfoKHR *pSignalInfo);