From 611905894e8b9ab70084baff383cf8d0b0cef160 Mon Sep 17 00:00:00 2001 From: baldurk Date: Mon, 21 Sep 2015 11:10:13 +0200 Subject: [PATCH] Add fence functions and a FlushMappedMemory that just prints for now --- renderdoc/driver/vulkan/vk_common.cpp | 57 ++++++++++ renderdoc/driver/vulkan/vk_common.h | 1 + renderdoc/driver/vulkan/vk_core.cpp | 6 +- renderdoc/driver/vulkan/vk_core.h | 20 ++++ renderdoc/driver/vulkan/vk_hookset_defs.h | 8 ++ .../driver/vulkan/wrappers/vk_misc_funcs.cpp | 104 +++++++++++++++++- .../vulkan/wrappers/vk_resource_funcs.cpp | 24 ++++ 7 files changed, 214 insertions(+), 6 deletions(-) diff --git a/renderdoc/driver/vulkan/vk_common.cpp b/renderdoc/driver/vulkan/vk_common.cpp index e3c0f2cc7..1580a0b5f 100644 --- a/renderdoc/driver/vulkan/vk_common.cpp +++ b/renderdoc/driver/vulkan/vk_common.cpp @@ -925,6 +925,19 @@ string ToStrHelper::Get(const VkCmdBufferOpt return ret; } +template<> +string ToStrHelper::Get(const VkFenceCreateFlagBits &el) +{ + string ret; + + if(el & VK_FENCE_CREATE_SIGNALED_BIT) ret += " | VK_FENCE_CREATE_SIGNALED_BIT"; + + if(!ret.empty()) + ret = ret.substr(3); + + return ret; +} + template<> string ToStrHelper::Get(const VkShaderStageFlagBits &el) { @@ -1377,6 +1390,38 @@ string ToStrHelper::Get(const VkDescriptorSetUsage return StringFormat::Fmt("VkDescriptorSetUsage<%d>", el); } +template<> +string ToStrHelper::Get(const VkMemoryHeapFlagBits &el) +{ + string ret; + + if(el & VK_MEMORY_HEAP_HOST_LOCAL) ret += " | VK_MEMORY_HEAP_HOST_LOCAL"; + + if(!ret.empty()) + ret = ret.substr(3); + + return ret; +} + +template<> +string ToStrHelper::Get(const VkMemoryPropertyFlagBits &el) +{ + string ret; + + if(el & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) ret += " | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT"; + if(el & VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT) ret += " | VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT"; + if(el & VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT) ret += " | VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT"; + if(el & VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT) ret += " | VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT"; + if(el & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) ret += " | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT"; + + if(!ret.empty()) + ret = ret.substr(3); + else + ret = "VK_MEMORY_PROPERTY_DEVICE_ONLY"; + + return ret; +} + template<> string ToStrHelper::Get(const VkMemoryInputFlagBits &el) { @@ -2541,6 +2586,18 @@ void Serialiser::Serialise(const char *name, VkSemaphoreCreateInfo &el) Serialise("flags", el.flags); } +template<> +void Serialiser::Serialise(const char *name, VkFenceCreateInfo &el) +{ + ScopedContext scope(this, this, name, "VkFenceCreateInfo", 0, true); + + RDCASSERT(m_Mode < WRITING || el.sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO); + Serialise("sType", el.sType); + SerialiseNext(this, el.pNext); + + Serialise("flags", (VkFenceCreateFlagBits &)el.flags); +} + template<> void Serialiser::Serialise(const char *name, VkSamplerCreateInfo &el) { diff --git a/renderdoc/driver/vulkan/vk_common.h b/renderdoc/driver/vulkan/vk_common.h index 6d1fd7fa3..ea3e4e46f 100644 --- a/renderdoc/driver/vulkan/vk_common.h +++ b/renderdoc/driver/vulkan/vk_common.h @@ -113,6 +113,7 @@ template<> void Serialiser::Serialise(const char *name, VkCmdBufferCreateInfo &e template<> void Serialiser::Serialise(const char *name, VkCmdBufferBeginInfo &el); template<> void Serialiser::Serialise(const char *name, VkStencilOpState &el); template<> void Serialiser::Serialise(const char *name, VkSemaphoreCreateInfo &el); +template<> void Serialiser::Serialise(const char *name, VkFenceCreateInfo &el); template<> void Serialiser::Serialise(const char *name, VkSamplerCreateInfo &el); template<> void Serialiser::Serialise(const char *name, VkPipelineCacheCreateInfo &el); template<> void Serialiser::Serialise(const char *name, VkShaderCreateInfo &el); diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index ad3543e4f..219c70bb4 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -963,12 +963,10 @@ void WrappedVulkan::ProcessChunk(uint64_t offset, VulkanChunkType context) Serialise_vkCreateSemaphore(VK_NULL_HANDLE, NULL, NULL); break; case CREATE_FENCE: - //VKTODOMED: - //Serialise_vkCreateFence(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateFence(VK_NULL_HANDLE, NULL, NULL); break; case GET_FENCE_STATUS: - //VKTODOMED: - //Serialise_vkGetFenceStatus(VK_NULL_HANDLE); + Serialise_vkGetFenceStatus(VK_NULL_HANDLE, VK_NULL_HANDLE); break; case WAIT_FENCES: //VKTODOMED: diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index 6434a64d4..ba06c2939 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -531,6 +531,21 @@ public: VkQueue queue, VkSemaphore semaphore)); + // Fence functions + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + VkFence* pFence)); + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyFence( + VkDevice device, + VkFence fence)); + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetFenceStatus( + VkDevice device, + VkFence fence)); + // Memory functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAllocMemory( @@ -554,6 +569,11 @@ public: VkDevice device, VkDeviceMemory mem)); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memRangeCount, + const VkMappedMemoryRange* pMemRanges)); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, diff --git a/renderdoc/driver/vulkan/vk_hookset_defs.h b/renderdoc/driver/vulkan/vk_hookset_defs.h index 78b9959ee..dedc57578 100644 --- a/renderdoc/driver/vulkan/vk_hookset_defs.h +++ b/renderdoc/driver/vulkan/vk_hookset_defs.h @@ -51,6 +51,7 @@ HookInit(FreeMemory); \ HookInit(MapMemory); \ HookInit(UnmapMemory); \ + HookInit(FlushMappedMemoryRanges); \ HookInit(BindBufferMemory); \ HookInit(BindImageMemory); \ HookInit(CreateBuffer); \ @@ -80,6 +81,9 @@ HookInit(DestroySemaphore); \ HookInit(QueueSignalSemaphore); \ HookInit(QueueWaitSemaphore); \ + HookInit(CreateFence); \ + HookInit(GetFenceStatus); \ + HookInit(DestroyFence); \ HookInit(CreateSampler); \ HookInit(DestroySampler); \ HookInit(CreateDescriptorSetLayout); \ @@ -166,6 +170,7 @@ HookDefine2(VkResult, vkFreeMemory, VkDevice, device, VkDeviceMemory, mem); \ HookDefine6(VkResult, vkMapMemory, VkDevice, device, VkDeviceMemory, mem, VkDeviceSize, offset, VkDeviceSize, size, VkMemoryMapFlags, flags, void**, ppData); \ HookDefine2(VkResult, vkUnmapMemory, VkDevice, device, VkDeviceMemory, mem); \ + HookDefine3(VkResult, vkFlushMappedMemoryRanges, VkDevice, device, uint32_t, memRangeCount, const VkMappedMemoryRange*, pMemRanges); \ HookDefine4(VkResult, vkBindBufferMemory, VkDevice, device, VkBuffer, buffer, VkDeviceMemory, mem, VkDeviceSize, memOffset); \ HookDefine4(VkResult, vkBindImageMemory, VkDevice, device, VkImage, image, VkDeviceMemory, mem, VkDeviceSize, memOffset); \ HookDefine3(VkResult, vkCreateBuffer, VkDevice, device, const VkBufferCreateInfo*, pCreateInfo, VkBuffer*, pBuffer); \ @@ -195,6 +200,9 @@ HookDefine2(VkResult, vkDestroySemaphore, VkDevice, device, VkSemaphore, semaphore); \ HookDefine2(VkResult, vkQueueSignalSemaphore, VkQueue, queue, VkSemaphore, semaphore); \ HookDefine2(VkResult, vkQueueWaitSemaphore, VkQueue, queue, VkSemaphore, semaphore); \ + HookDefine3(VkResult, vkCreateFence, VkDevice, device, const VkFenceCreateInfo*, pCreateInfo, VkFence*, pFence); \ + HookDefine2(VkResult, vkDestroyFence, VkDevice, device, VkFence, fence); \ + HookDefine2(VkResult, vkGetFenceStatus, VkDevice, device, VkFence, fence); \ HookDefine3(VkResult, vkCreateSampler, VkDevice, device, const VkSamplerCreateInfo*, pCreateInfo, VkSampler*, pSampler); \ HookDefine2(VkResult, vkDestroySampler, VkDevice, device, VkSampler, sampler); \ HookDefine3(VkResult, vkCreateDescriptorSetLayout, VkDevice, device, const VkDescriptorSetLayoutCreateInfo*, pCreateInfo, VkDescriptorSetLayout*, pSetLayout); \ diff --git a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp index 1e4dce648..b443c6cf4 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp @@ -51,6 +51,7 @@ DESTROY_IMPL(VkDynamicRasterState, DestroyDynamicRasterState) DESTROY_IMPL(VkDynamicColorBlendState, DestroyDynamicColorBlendState) DESTROY_IMPL(VkDynamicDepthStencilState, DestroyDynamicDepthStencilState) DESTROY_IMPL(VkSemaphore, DestroySemaphore) +DESTROY_IMPL(VkFence, DestroyFence) DESTROY_IMPL(VkCmdPool, DestroyCommandPool) DESTROY_IMPL(VkFramebuffer, DestroyFramebuffer) DESTROY_IMPL(VkRenderPass, DestroyRenderPass) @@ -196,8 +197,7 @@ bool WrappedVulkan::ReleaseResource(WrappedVkRes *res) vt->DestroyCommandPool(Unwrap(dev), nondisp->real.As()); break; case eResFence: - // VKTODOLOW - //vt->DestroyFence(Unwrap(dev), nondisp->real.As()); + vt->DestroyFence(Unwrap(dev), nondisp->real.As()); break; case eResEvent: // VKTODOLOW @@ -376,6 +376,106 @@ bool WrappedVulkan::Serialise_vkCreateFramebuffer( return true; } +bool WrappedVulkan::Serialise_vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + VkFence* pFence) +{ + SERIALISE_ELEMENT(ResourceId, devId, GetResID(device)); + SERIALISE_ELEMENT(VkFenceCreateInfo, info, *pCreateInfo); + SERIALISE_ELEMENT(ResourceId, id, GetResID(*pFence)); + + if(m_State == READING) + { + device = GetResourceManager()->GetLiveHandle(devId); + VkFence sem = VK_NULL_HANDLE; + + VkResult ret = ObjDisp(device)->CreateFence(Unwrap(device), &info, &sem); + + if(ret != VK_SUCCESS) + { + RDCERR("Failed on resource serialise-creation, VkResult: 0x%08x", ret); + } + else + { + ResourceId live = GetResourceManager()->WrapResource(Unwrap(device), sem); + GetResourceManager()->AddLiveResource(id, sem); + } + } + + return true; +} + +VkResult WrappedVulkan::vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + VkFence* pFence) +{ + VkResult ret = ObjDisp(device)->CreateFence(Unwrap(device), pCreateInfo, pFence); + + if(ret == VK_SUCCESS) + { + ResourceId id = GetResourceManager()->WrapResource(Unwrap(device), *pFence); + + if(m_State >= WRITING) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(CREATE_FENCE); + Serialise_vkCreateFence(device, pCreateInfo, pFence); + + chunk = scope.Get(); + } + + VkResourceRecord *record = GetResourceManager()->AddResourceRecord(*pFence); + record->AddChunk(chunk); + } + else + { + GetResourceManager()->AddLiveResource(id, *pFence); + } + } + + return ret; +} + +bool WrappedVulkan::Serialise_vkGetFenceStatus( + VkDevice device, + VkFence fence) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResID(device)); + SERIALISE_ELEMENT(ResourceId, fid, GetResID(fence)); + + if(m_State < WRITING) + { + device = GetResourceManager()->GetLiveHandle(id); + + // VKTODOLOW conservatively assume we have to wait for the device to be idle + // this could probably be smarter + ObjDisp(device)->DeviceWaitIdle(Unwrap(device)); + } + + return true; +} + +VkResult WrappedVulkan::vkGetFenceStatus( + VkDevice device, + VkFence fence) +{ + VkResult ret = ObjDisp(device)->GetFenceStatus(Unwrap(device), Unwrap(fence)); + + if(m_State >= WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(GET_FENCE_STATUS); + Serialise_vkGetFenceStatus(device, fence); + + m_FrameCaptureRecord->AddChunk(scope.Get()); + } + + return ret; +} + VkResult WrappedVulkan::vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, diff --git a/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp index dbb0e134a..c9cbe1c64 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp @@ -254,6 +254,30 @@ VkResult WrappedVulkan::vkUnmapMemory( return ret; } +VkResult WrappedVulkan::vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memRangeCount, + const VkMappedMemoryRange* pMemRanges) +{ + VkMappedMemoryRange *unwrapped = new VkMappedMemoryRange[memRangeCount]; + for(uint32_t i=0; i < memRangeCount; i++) + { + unwrapped[i] = pMemRanges[i]; + unwrapped[i].mem = Unwrap(unwrapped[i].mem); + } + + VkResult ret = ObjDisp(device)->FlushMappedMemoryRanges(Unwrap(device), memRangeCount, unwrapped); + + SAFE_DELETE_ARRAY(unwrapped); + + for(uint32_t i=0; i < memRangeCount; i++) + { + RDCDEBUG("FlushMemory(%p, %llu, %llu)", pMemRanges[i].mem, pMemRanges[i].offset, pMemRanges[i].size); + } + + return ret; +} + // Generic API object functions bool WrappedVulkan::Serialise_vkBindBufferMemory(