From 8b595f5f43fbd29618a1c550a70401ba76a7378f Mon Sep 17 00:00:00 2001 From: baldurk Date: Mon, 5 Oct 2015 18:30:55 +0200 Subject: [PATCH] Move serialiser to locally cached variable per-function invocation --- renderdoc/driver/vulkan/vk_common.h | 2 +- renderdoc/driver/vulkan/vk_core.cpp | 189 ++++--- renderdoc/driver/vulkan/vk_core.h | 530 +++++++++--------- renderdoc/driver/vulkan/vk_initstate.cpp | 3 + renderdoc/driver/vulkan/vk_manager.cpp | 2 + renderdoc/driver/vulkan/vk_replay.cpp | 6 +- .../driver/vulkan/wrappers/vk_cmd_funcs.cpp | 117 +++- .../vulkan/wrappers/vk_descriptor_funcs.cpp | 24 +- .../vulkan/wrappers/vk_device_funcs.cpp | 16 +- .../driver/vulkan/wrappers/vk_draw_funcs.cpp | 92 ++- .../driver/vulkan/wrappers/vk_misc_funcs.cpp | 55 +- .../driver/vulkan/wrappers/vk_queue_funcs.cpp | 30 +- .../vulkan/wrappers/vk_resource_funcs.cpp | 50 +- .../vulkan/wrappers/vk_shader_funcs.cpp | 25 +- .../driver/vulkan/wrappers/vk_wsi_funcs.cpp | 14 +- renderdoc/serialise/serialiser.h | 23 +- 16 files changed, 719 insertions(+), 459 deletions(-) diff --git a/renderdoc/driver/vulkan/vk_common.h b/renderdoc/driver/vulkan/vk_common.h index 0eb29f44c..95fc591e6 100644 --- a/renderdoc/driver/vulkan/vk_common.h +++ b/renderdoc/driver/vulkan/vk_common.h @@ -74,7 +74,7 @@ struct VkGenericStruct const VkGenericStruct *pNext; }; -#define IMPLEMENT_FUNCTION_SERIALISED(ret, func) ret func; bool CONCAT(Serialise_, func); +#define IMPLEMENT_FUNCTION_SERIALISED(ret, func, ...) ret func(__VA_ARGS__); bool CONCAT(Serialise_, func(Serialiser *localSerialiser, __VA_ARGS__)); template<> void Serialiser::Serialise(const char *name, VkRect2D &el); template<> void Serialiser::Serialise(const char *name, VkRect3D &el); diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index 104290c49..8e169ef67 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -154,6 +154,8 @@ VkInitParams::VkInitParams() ReplayCreateStatus VkInitParams::Serialise() { + Serialiser *localSerialiser = GetSerialiser(); + SERIALISE_ELEMENT(uint32_t, ver, VK_SERIALISE_VERSION); SerialiseVersion = ver; if(ver != VK_SERIALISE_VERSION) @@ -162,16 +164,16 @@ ReplayCreateStatus VkInitParams::Serialise() return eReplayCreate_APIIncompatibleVersion; } - GetSerialiser()->Serialise("AppName", AppName); - GetSerialiser()->Serialise("EngineName", EngineName); - GetSerialiser()->Serialise("AppVersion", AppVersion); - GetSerialiser()->Serialise("EngineVersion", EngineVersion); - GetSerialiser()->Serialise("APIVersion", APIVersion); + localSerialiser->Serialise("AppName", AppName); + localSerialiser->Serialise("EngineName", EngineName); + localSerialiser->Serialise("AppVersion", AppVersion); + localSerialiser->Serialise("EngineVersion", EngineVersion); + localSerialiser->Serialise("APIVersion", APIVersion); - GetSerialiser()->Serialise("Layers", Layers); - GetSerialiser()->Serialise("Extensions", Extensions); + localSerialiser->Serialise("Layers", Layers); + localSerialiser->Serialise("Extensions", Extensions); - GetSerialiser()->Serialise("InstanceID", InstanceID); + localSerialiser->Serialise("InstanceID", InstanceID); return eReplayCreate_Success; } @@ -408,6 +410,11 @@ const char * WrappedVulkan::GetChunkName(uint32_t idx) return VkChunkNames[idx-FIRST_CHUNK_ID]; } +Serialiser *WrappedVulkan::GetThreadSerialiser() +{ + return m_pSerialiser; +} + void WrappedVulkan::Serialise_CaptureScope(uint64_t offset) { uint32_t FrameNumber = m_FrameCounter; @@ -432,6 +439,8 @@ void WrappedVulkan::Serialise_CaptureScope(uint64_t offset) void WrappedVulkan::EndCaptureFrame(VkImage presentImage) { + Serialiser *localSerialiser = GetMainSerialiser(); + SCOPED_SERIALISE_CONTEXT(CONTEXT_CAPTURE_FOOTER); SERIALISE_ELEMENT(ResourceId, bbid, GetResID(presentImage)); @@ -529,6 +538,8 @@ bool WrappedVulkan::Serialise_BeginCaptureFrame(bool applyInitialState) void WrappedVulkan::BeginCaptureFrame() { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CONTEXT_CAPTURE_HEADER); Serialise_BeginCaptureFrame(false); @@ -839,265 +850,265 @@ void WrappedVulkan::ProcessChunk(uint64_t offset, VulkanChunkType context) break; } case ENUM_PHYSICALS: - Serialise_vkEnumeratePhysicalDevices(NULL, NULL, NULL); + Serialise_vkEnumeratePhysicalDevices(GetMainSerialiser(), NULL, NULL, NULL); break; case CREATE_DEVICE: - Serialise_vkCreateDevice(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateDevice(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case GET_DEVICE_QUEUE: - Serialise_vkGetDeviceQueue(VK_NULL_HANDLE, 0, 0, NULL); + Serialise_vkGetDeviceQueue(GetMainSerialiser(), VK_NULL_HANDLE, 0, 0, NULL); break; case ALLOC_MEM: - Serialise_vkAllocMemory(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkAllocMemory(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case UNMAP_MEM: - Serialise_vkUnmapMemory(VK_NULL_HANDLE, VK_NULL_HANDLE); + Serialise_vkUnmapMemory(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); break; case FLUSH_MEM: - Serialise_vkFlushMappedMemoryRanges(VK_NULL_HANDLE, 0, NULL); + Serialise_vkFlushMappedMemoryRanges(GetMainSerialiser(), VK_NULL_HANDLE, 0, NULL); break; case FREE_MEM: // VKTODOMED see vkFreeMemory - //Serialise_vkFreeMemory(VK_NULL_HANDLE, VK_NULL_HANDLE); + //Serialise_vkFreeMemory(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); //break; case CREATE_CMD_POOL: - Serialise_vkCreateCommandPool(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateCommandPool(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_CMD_BUFFER: RDCERR("vkCreateCommandBuffer should not be serialised directly"); break; case CREATE_FRAMEBUFFER: - Serialise_vkCreateFramebuffer(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateFramebuffer(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_RENDERPASS: - Serialise_vkCreateRenderPass(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateRenderPass(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_DESCRIPTOR_POOL: - Serialise_vkCreateDescriptorPool(VK_NULL_HANDLE, VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM, 0, NULL, NULL); + Serialise_vkCreateDescriptorPool(GetMainSerialiser(), VK_NULL_HANDLE, VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM, 0, NULL, NULL); break; case CREATE_DESCRIPTOR_SET_LAYOUT: - Serialise_vkCreateDescriptorSetLayout(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateDescriptorSetLayout(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_BUFFER: - Serialise_vkCreateBuffer(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateBuffer(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_BUFFER_VIEW: - Serialise_vkCreateBufferView(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateBufferView(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_IMAGE: - Serialise_vkCreateImage(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateImage(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_IMAGE_VIEW: - Serialise_vkCreateImageView(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateImageView(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_ATTACHMENT_VIEW: - Serialise_vkCreateAttachmentView(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateAttachmentView(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_VIEWPORT_STATE: - Serialise_vkCreateDynamicViewportState(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateDynamicViewportState(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_RASTER_STATE: - Serialise_vkCreateDynamicRasterState(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateDynamicRasterState(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_BLEND_STATE: - Serialise_vkCreateDynamicColorBlendState(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateDynamicColorBlendState(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_DEPTH_STATE: - Serialise_vkCreateDynamicDepthStencilState(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateDynamicDepthStencilState(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_SAMPLER: - Serialise_vkCreateSampler(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateSampler(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_SHADER: - Serialise_vkCreateShader(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateShader(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_SHADER_MODULE: - Serialise_vkCreateShaderModule(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateShaderModule(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_PIPE_LAYOUT: - Serialise_vkCreatePipelineLayout(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreatePipelineLayout(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_PIPE_CACHE: - Serialise_vkCreatePipelineCache(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreatePipelineCache(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_GRAPHICS_PIPE: - Serialise_vkCreateGraphicsPipelines(VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL, NULL); + Serialise_vkCreateGraphicsPipelines(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL, NULL); break; case CREATE_COMPUTE_PIPE: //VKTODOMED: - //Serialise_vkCreateComputePipelines(VK_NULL_HANDLE, NULL, NULL); + //Serialise_vkCreateComputePipelines(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case PRESENT_IMAGE: - Serialise_vkGetSwapChainInfoWSI(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_SWAP_CHAIN_INFO_TYPE_MAX_ENUM_WSI, NULL, NULL); + Serialise_vkGetSwapChainInfoWSI(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_SWAP_CHAIN_INFO_TYPE_MAX_ENUM_WSI, NULL, NULL); break; case CREATE_SEMAPHORE: - Serialise_vkCreateSemaphore(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateSemaphore(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CREATE_FENCE: - Serialise_vkCreateFence(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateFence(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case GET_FENCE_STATUS: - Serialise_vkGetFenceStatus(VK_NULL_HANDLE, VK_NULL_HANDLE); + Serialise_vkGetFenceStatus(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); break; case WAIT_FENCES: //VKTODOMED: - //Serialise_vkWaitForFences(VK_NULL_HANDLE, 0, NULL, VK_FALSE, 0.0f); + //Serialise_vkWaitForFences(GetMainSerialiser(), VK_NULL_HANDLE, 0, NULL, VK_FALSE, 0.0f); break; case CREATE_QUERY_POOL: - Serialise_vkCreateQueryPool(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateQueryPool(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case ALLOC_DESC_SET: - Serialise_vkAllocDescriptorSets(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_DESCRIPTOR_SET_USAGE_MAX_ENUM, 0, NULL, NULL, NULL); + Serialise_vkAllocDescriptorSets(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_DESCRIPTOR_SET_USAGE_MAX_ENUM, 0, NULL, NULL, NULL); break; case UPDATE_DESC_SET: - Serialise_vkUpdateDescriptorSets(VK_NULL_HANDLE, 0, NULL, 0, NULL); + Serialise_vkUpdateDescriptorSets(GetMainSerialiser(), VK_NULL_HANDLE, 0, NULL, 0, NULL); break; case RESET_CMD_BUFFER: - Serialise_vkResetCommandBuffer(VK_NULL_HANDLE, 0); + Serialise_vkResetCommandBuffer(GetMainSerialiser(), VK_NULL_HANDLE, 0); break; case BEGIN_CMD_BUFFER: - Serialise_vkBeginCommandBuffer(VK_NULL_HANDLE, NULL); + Serialise_vkBeginCommandBuffer(GetMainSerialiser(), VK_NULL_HANDLE, NULL); break; case END_CMD_BUFFER: - Serialise_vkEndCommandBuffer(VK_NULL_HANDLE); + Serialise_vkEndCommandBuffer(GetMainSerialiser(), VK_NULL_HANDLE); break; case QUEUE_SIGNAL_SEMAPHORE: - Serialise_vkQueueSignalSemaphore(VK_NULL_HANDLE, VK_NULL_HANDLE); + Serialise_vkQueueSignalSemaphore(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); break; case QUEUE_WAIT_SEMAPHORE: - Serialise_vkQueueWaitSemaphore(VK_NULL_HANDLE, VK_NULL_HANDLE); + Serialise_vkQueueWaitSemaphore(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); break; case QUEUE_WAIT_IDLE: - Serialise_vkQueueWaitIdle(VK_NULL_HANDLE); + Serialise_vkQueueWaitIdle(GetMainSerialiser(), VK_NULL_HANDLE); break; case DEVICE_WAIT_IDLE: - Serialise_vkDeviceWaitIdle(VK_NULL_HANDLE); + Serialise_vkDeviceWaitIdle(GetMainSerialiser(), VK_NULL_HANDLE); break; case QUEUE_SUBMIT: - Serialise_vkQueueSubmit(VK_NULL_HANDLE, 0, NULL, VK_NULL_HANDLE); + Serialise_vkQueueSubmit(GetMainSerialiser(), VK_NULL_HANDLE, 0, NULL, VK_NULL_HANDLE); break; case BIND_BUFFER_MEM: - Serialise_vkBindBufferMemory(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0); + Serialise_vkBindBufferMemory(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0); break; case BIND_IMAGE_MEM: - Serialise_vkBindImageMemory(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0); + Serialise_vkBindImageMemory(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0); break; case BEGIN_RENDERPASS: - Serialise_vkCmdBeginRenderPass(VK_NULL_HANDLE, NULL, VK_RENDER_PASS_CONTENTS_MAX_ENUM); + Serialise_vkCmdBeginRenderPass(GetMainSerialiser(), VK_NULL_HANDLE, NULL, VK_RENDER_PASS_CONTENTS_MAX_ENUM); break; case END_RENDERPASS: - Serialise_vkCmdEndRenderPass(VK_NULL_HANDLE); + Serialise_vkCmdEndRenderPass(GetMainSerialiser(), VK_NULL_HANDLE); break; case BIND_PIPELINE: - Serialise_vkCmdBindPipeline(VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, VK_NULL_HANDLE); + Serialise_vkCmdBindPipeline(GetMainSerialiser(), VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, VK_NULL_HANDLE); break; case BIND_VP_STATE: - Serialise_vkCmdBindDynamicViewportState(VK_NULL_HANDLE, VK_NULL_HANDLE); + Serialise_vkCmdBindDynamicViewportState(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); break; case BIND_RS_STATE: - Serialise_vkCmdBindDynamicRasterState(VK_NULL_HANDLE, VK_NULL_HANDLE); + Serialise_vkCmdBindDynamicRasterState(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); break; case BIND_CB_STATE: - Serialise_vkCmdBindDynamicColorBlendState(VK_NULL_HANDLE, VK_NULL_HANDLE); + Serialise_vkCmdBindDynamicColorBlendState(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); break; case BIND_DS_STATE: - Serialise_vkCmdBindDynamicDepthStencilState(VK_NULL_HANDLE, VK_NULL_HANDLE); + Serialise_vkCmdBindDynamicDepthStencilState(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE); break; case BIND_DESCRIPTOR_SET: - Serialise_vkCmdBindDescriptorSets(VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, VK_NULL_HANDLE, 0, 0, NULL, 0, NULL); + Serialise_vkCmdBindDescriptorSets(GetMainSerialiser(), VK_NULL_HANDLE, VK_PIPELINE_BIND_POINT_MAX_ENUM, VK_NULL_HANDLE, 0, 0, NULL, 0, NULL); break; case BIND_INDEX_BUFFER: - Serialise_vkCmdBindIndexBuffer(VK_NULL_HANDLE, VK_NULL_HANDLE, 0, VK_INDEX_TYPE_MAX_ENUM); + Serialise_vkCmdBindIndexBuffer(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, 0, VK_INDEX_TYPE_MAX_ENUM); break; case BIND_VERTEX_BUFFERS: - Serialise_vkCmdBindVertexBuffers(VK_NULL_HANDLE, 0, 0, NULL, NULL); + Serialise_vkCmdBindVertexBuffers(GetMainSerialiser(), VK_NULL_HANDLE, 0, 0, NULL, NULL); break; case COPY_BUF2IMG: - Serialise_vkCmdCopyBufferToImage(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL); + Serialise_vkCmdCopyBufferToImage(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL); break; case COPY_IMG2BUF: - Serialise_vkCmdCopyImageToBuffer(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, 0, NULL); + Serialise_vkCmdCopyImageToBuffer(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, 0, NULL); break; case COPY_IMG: - Serialise_vkCmdCopyImage(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL); + Serialise_vkCmdCopyImage(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL); break; case BLIT_IMG: - Serialise_vkCmdBlitImage(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL, VK_TEX_FILTER_MAX_ENUM); + Serialise_vkCmdBlitImage(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL, VK_TEX_FILTER_MAX_ENUM); break; case RESOLVE_IMG: - Serialise_vkCmdResolveImage(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL); + Serialise_vkCmdResolveImage(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0, NULL); break; case COPY_BUF: - Serialise_vkCmdCopyBuffer(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL); + Serialise_vkCmdCopyBuffer(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, NULL); break; case CLEAR_COLOR: - Serialise_vkCmdClearColorImage(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, NULL, 0, NULL); + Serialise_vkCmdClearColorImage(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, NULL, 0, NULL); break; case CLEAR_DEPTHSTENCIL: - Serialise_vkCmdClearDepthStencilImage(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0.0f, 0, 0, NULL); + Serialise_vkCmdClearDepthStencilImage(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0.0f, 0, 0, NULL); break; case CLEAR_COLOR_ATTACH: - Serialise_vkCmdClearColorAttachment(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, NULL, 0, NULL); + Serialise_vkCmdClearColorAttachment(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, NULL, 0, NULL); break; case CLEAR_DEPTHSTENCIL_ATTACH: - Serialise_vkCmdClearDepthStencilAttachment(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0.0f, 0, 0, NULL); + Serialise_vkCmdClearDepthStencilAttachment(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_IMAGE_LAYOUT_MAX_ENUM, 0.0f, 0, 0, NULL); break; case PIPELINE_BARRIER: - Serialise_vkCmdPipelineBarrier(VK_NULL_HANDLE, 0, 0, VK_FALSE, 0, NULL); + Serialise_vkCmdPipelineBarrier(GetMainSerialiser(), VK_NULL_HANDLE, 0, 0, VK_FALSE, 0, NULL); break; case WRITE_TIMESTAMP: //VKTODOMED: - //Serialise_vkCmdWriteTimestamp(VK_NULL_HANDLE, VK_TIMESTAMP_TYPE_MAX_ENUM, VK_NULL_HANDLE, 0); + //Serialise_vkCmdWriteTimestamp(GetMainSerialiser(), VK_NULL_HANDLE, VK_TIMESTAMP_TYPE_MAX_ENUM, VK_NULL_HANDLE, 0); break; case BEGIN_QUERY: - Serialise_vkCmdBeginQuery(VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); + Serialise_vkCmdBeginQuery(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); break; case END_QUERY: - Serialise_vkCmdEndQuery(VK_NULL_HANDLE, VK_NULL_HANDLE, 0); + Serialise_vkCmdEndQuery(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, 0); break; case RESET_QUERY_POOL: - Serialise_vkCmdResetQueryPool(VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); + Serialise_vkCmdResetQueryPool(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); break; case DRAW: - Serialise_vkCmdDraw(VK_NULL_HANDLE, 0, 0, 0, 0); + Serialise_vkCmdDraw(GetMainSerialiser(), VK_NULL_HANDLE, 0, 0, 0, 0); break; case DRAW_INDIRECT: - Serialise_vkCmdDrawIndirect(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); + Serialise_vkCmdDrawIndirect(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); break; case DRAW_INDEXED: - Serialise_vkCmdDrawIndexed(VK_NULL_HANDLE, 0, 0, 0, 0, 0); + Serialise_vkCmdDrawIndexed(GetMainSerialiser(), VK_NULL_HANDLE, 0, 0, 0, 0, 0); break; case DRAW_INDEXED_INDIRECT: - Serialise_vkCmdDrawIndexedIndirect(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); + Serialise_vkCmdDrawIndexedIndirect(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); break; case DISPATCH: - Serialise_vkCmdDispatch(VK_NULL_HANDLE, 0, 0, 0); + Serialise_vkCmdDispatch(GetMainSerialiser(), VK_NULL_HANDLE, 0, 0, 0); break; case DISPATCH_INDIRECT: - Serialise_vkCmdDispatchIndirect(VK_NULL_HANDLE, VK_NULL_HANDLE, 0); + Serialise_vkCmdDispatchIndirect(GetMainSerialiser(), VK_NULL_HANDLE, VK_NULL_HANDLE, 0); break; case BEGIN_EVENT: - Serialise_vkCmdDbgMarkerBegin(VK_NULL_HANDLE, NULL); + Serialise_vkCmdDbgMarkerBegin(GetMainSerialiser(), VK_NULL_HANDLE, NULL); break; case SET_MARKER: RDCFATAL("No such function vkCmdDbgMarker"); break; case END_EVENT: - Serialise_vkCmdDbgMarkerEnd(VK_NULL_HANDLE); + Serialise_vkCmdDbgMarkerEnd(GetMainSerialiser(), VK_NULL_HANDLE); break; case CREATE_SWAP_BUFFER: - Serialise_vkCreateSwapChainWSI(VK_NULL_HANDLE, NULL, NULL); + Serialise_vkCreateSwapChainWSI(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL); break; case CAPTURE_SCOPE: @@ -1105,6 +1116,8 @@ void WrappedVulkan::ProcessChunk(uint64_t offset, VulkanChunkType context) break; case CONTEXT_CAPTURE_FOOTER: { + Serialiser *localSerialiser = GetMainSerialiser(); + SERIALISE_ELEMENT(ResourceId, bbid, ResourceId()); ResourceId liveBBid = GetResourceManager()->GetLiveID(bbid); diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index f76db30f9..449d578be 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -86,6 +86,17 @@ struct DrawcallTreeNode } }; +// use locally cached serialiser, per-thread +#undef GET_SERIALISER +#define GET_SERIALISER localSerialiser + +// must be at the start of any function that serialises +#define CACHE_THREAD_SERIALISER() Serialiser *localSerialiser = GetThreadSerialiser(); + +// pass the cached serialiser into Serialised_ function +#undef SERIALISED_PARAMETER +#define SERIALISED_PARAMETER Serialiser *localSerialiser, + class WrappedVulkan { private: @@ -362,7 +373,8 @@ private: static const char *GetChunkName(uint32_t idx); - Serialiser *GetSerialiser() { return m_pSerialiser; } + Serialiser *GetThreadSerialiser(); + Serialiser *GetMainSerialiser() { return m_pSerialiser; } void Serialise_CaptureScope(uint64_t offset); bool HasSuccessfulCapture(); @@ -454,469 +466,469 @@ public: // Device initialization - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateInstance( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateInstance, const VkInstanceCreateInfo* pCreateInfo, - VkInstance* pInstance)); + VkInstance* pInstance); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyInstance( - VkInstance instance)); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyInstance, + VkInstance instance); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkEnumeratePhysicalDevices( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkEnumeratePhysicalDevices, VkInstance instance, uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices)); + VkPhysicalDevice* pPhysicalDevices); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceFeatures( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceFeatures, VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures* pFeatures)); + VkPhysicalDeviceFeatures* pFeatures); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceFormatProperties( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceFormatProperties, VkPhysicalDevice physicalDevice, VkFormat format, - VkFormatProperties* pFormatProperties)); + VkFormatProperties* pFormatProperties); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceImageFormatProperties( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceImageFormatProperties, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, - VkImageFormatProperties* pImageFormatProperties)); + VkImageFormatProperties* pImageFormatProperties); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceLimits( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceLimits, VkPhysicalDevice physicalDevice, - VkPhysicalDeviceLimits* pLimits)); + VkPhysicalDeviceLimits* pLimits); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceProperties( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceProperties, VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties)); + VkPhysicalDeviceProperties* pProperties); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceQueueCount( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceQueueCount, VkPhysicalDevice physicalDevice, - uint32_t* pCount)); + uint32_t* pCount); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceQueueProperties( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceQueueProperties, VkPhysicalDevice physicalDevice, uint32_t count, - VkPhysicalDeviceQueueProperties* pQueueProperties)); + VkPhysicalDeviceQueueProperties* pQueueProperties); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceMemoryProperties( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceMemoryProperties, VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties* pMemoryProperties)); + VkPhysicalDeviceMemoryProperties* pMemoryProperties); // Device functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDevice( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDevice, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, - VkDevice* pDevice)); + VkDevice* pDevice); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDevice( - VkDevice device)); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDevice, + VkDevice device); // Queue functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetDeviceQueue( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetDeviceQueue, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, - VkQueue* pQueue)); + VkQueue* pQueue); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueSubmit( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueSubmit, VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, - VkFence fence)); + VkFence fence); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueAddMemReferences( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueAddMemReferences, VkQueue queue, uint32_t count, - const VkDeviceMemory* pMems)); + const VkDeviceMemory* pMems); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueRemoveMemReferences( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueRemoveMemReferences, VkQueue queue, uint32_t count, - const VkDeviceMemory* pMems)); + const VkDeviceMemory* pMems); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueWaitIdle( - VkQueue queue)); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueWaitIdle, + VkQueue queue); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDeviceWaitIdle( - VkDevice device)); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDeviceWaitIdle, + VkDevice device); // Query pool functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateQueryPool( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateQueryPool, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, - VkQueryPool* pQueryPool)); + VkQueryPool* pQueryPool); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyQueryPool( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyQueryPool, VkDevice device, - VkQueryPool queryPool)); + VkQueryPool queryPool); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetQueryPoolResults( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetQueryPoolResults, VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, - VkQueryResultFlags flags)); + VkQueryResultFlags flags); // Semaphore functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateSemaphore( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateSemaphore, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, - VkSemaphore* pSemaphore)); + VkSemaphore* pSemaphore); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroySemaphore( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroySemaphore, VkDevice device, - VkSemaphore semaphore)); + VkSemaphore semaphore); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueSignalSemaphore( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueSignalSemaphore, VkQueue queue, - VkSemaphore semaphore)); + VkSemaphore semaphore); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueWaitSemaphore( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueueWaitSemaphore, VkQueue queue, - VkSemaphore semaphore)); + VkSemaphore semaphore); // Fence functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateFence( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateFence, VkDevice device, const VkFenceCreateInfo* pCreateInfo, - VkFence* pFence)); + VkFence* pFence); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyFence( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyFence, VkDevice device, - VkFence fence)); + VkFence fence); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetFenceStatus( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetFenceStatus, VkDevice device, - VkFence fence)); + VkFence fence); // Memory functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAllocMemory( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAllocMemory, VkDevice device, const VkMemoryAllocInfo* pAllocInfo, - VkDeviceMemory* pMem)); + VkDeviceMemory* pMem); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkFreeMemory( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkFreeMemory, VkDevice device, - VkDeviceMemory mem)); + VkDeviceMemory mem); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkMapMemory( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkMapMemory, VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, - void** ppData)); + void** ppData); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkUnmapMemory( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkUnmapMemory, VkDevice device, - VkDeviceMemory mem)); + VkDeviceMemory mem); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkFlushMappedMemoryRanges( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkFlushMappedMemoryRanges, VkDevice device, uint32_t memRangeCount, - const VkMappedMemoryRange* pMemRanges)); + const VkMappedMemoryRange* pMemRanges); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetBufferMemoryRequirements( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetBufferMemoryRequirements, VkDevice device, VkBuffer buffer, - VkMemoryRequirements* pMemoryRequirements)); + VkMemoryRequirements* pMemoryRequirements); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetImageMemoryRequirements( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetImageMemoryRequirements, VkDevice device, VkImage image, - VkMemoryRequirements* pMemoryRequirements)); + VkMemoryRequirements* pMemoryRequirements); // Memory management API functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkBindBufferMemory( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkBindBufferMemory, VkDevice device, VkBuffer buffer, VkDeviceMemory mem, - VkDeviceSize memOffset)); + VkDeviceSize memOffset); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkBindImageMemory( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkBindImageMemory, VkDevice device, VkImage image, VkDeviceMemory mem, - VkDeviceSize memOffset)); + VkDeviceSize memOffset); // Buffer functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateBuffer( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateBuffer, VkDevice device, const VkBufferCreateInfo* pCreateInfo, - VkBuffer* pBuffer)); + VkBuffer* pBuffer); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyBuffer( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyBuffer, VkDevice device, - VkBuffer buffer)); + VkBuffer buffer); // Buffer view functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateBufferView( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateBufferView, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, - VkBufferView* pView)); + VkBufferView* pView); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyBufferView( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyBufferView, VkDevice device, - VkBufferView view)); + VkBufferView view); // Image functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateImage( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateImage, VkDevice device, const VkImageCreateInfo* pCreateInfo, - VkImage* pImage)); + VkImage* pImage); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyImage( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyImage, VkDevice device, - VkImage image)); + VkImage image); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetImageSubresourceLayout( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetImageSubresourceLayout, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout)); + VkSubresourceLayout* pLayout); // Image view functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateImageView( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateImageView, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, - VkImageView* pView)); + VkImageView* pView); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyImageView( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyImageView, VkDevice device, - VkImageView view)); + VkImageView view); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateAttachmentView( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateAttachmentView, VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, - VkAttachmentView* pView)); + VkAttachmentView* pView); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyAttachmentView( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyAttachmentView, VkDevice device, - VkAttachmentView view)); + VkAttachmentView view); // Shader functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateShaderModule( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateShaderModule, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, - VkShaderModule* pShaderModule)); + VkShaderModule* pShaderModule); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyShaderModule( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyShaderModule, VkDevice device, - VkShaderModule shaderModule)); + VkShaderModule shaderModule); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateShader( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateShader, VkDevice device, const VkShaderCreateInfo* pCreateInfo, - VkShader* pShader)); + VkShader* pShader); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyShader( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyShader, VkDevice device, - VkShader shader)); + VkShader shader); // Pipeline functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateGraphicsPipelines( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateGraphicsPipelines, VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, - VkPipeline* pPipelines)); + VkPipeline* pPipelines); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyPipeline( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyPipeline, VkDevice device, - VkPipeline pipeline)); + VkPipeline pipeline); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreatePipelineCache( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreatePipelineCache, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, - VkPipelineCache* pPipelineCache)); + VkPipelineCache* pPipelineCache); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyPipelineCache( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyPipelineCache, VkDevice device, - VkPipelineCache pipelineCache)); + VkPipelineCache pipelineCache); // Pipeline layout functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreatePipelineLayout( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreatePipelineLayout, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, - VkPipelineLayout* pPipelineLayout)); + VkPipelineLayout* pPipelineLayout); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyPipelineLayout( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyPipelineLayout, VkDevice device, - VkPipelineLayout pipelineLayout)); + VkPipelineLayout pipelineLayout); // Sampler functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateSampler( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateSampler, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, - VkSampler* pSampler)); + VkSampler* pSampler); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroySampler( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroySampler, VkDevice device, - VkSampler sampler)); + VkSampler sampler); // Descriptor set functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDescriptorSetLayout( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDescriptorSetLayout, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayout* pSetLayout)); + VkDescriptorSetLayout* pSetLayout); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDescriptorSetLayout( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDescriptorSetLayout, VkDevice device, - VkDescriptorSetLayout setLayout)); + VkDescriptorSetLayout setLayout); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDescriptorPool( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDescriptorPool, VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, - VkDescriptorPool* pDescriptorPool)); + VkDescriptorPool* pDescriptorPool); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDescriptorPool( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDescriptorPool, VkDevice device, - VkDescriptorPool descriptorPool)); + VkDescriptorPool descriptorPool); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAllocDescriptorSets( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAllocDescriptorSets, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, - uint32_t* pCount)); + uint32_t* pCount); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkUpdateDescriptorSets( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkUpdateDescriptorSets, VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, - const VkCopyDescriptorSet* pDescriptorCopies)); + const VkCopyDescriptorSet* pDescriptorCopies); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkFreeDescriptorSets( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkFreeDescriptorSets, VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, - const VkDescriptorSet* pDescriptorSets)); + const VkDescriptorSet* pDescriptorSets); // State object functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDynamicViewportState( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDynamicViewportState, VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, - VkDynamicViewportState* pState)); + VkDynamicViewportState* pState); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDynamicViewportState( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDynamicViewportState, VkDevice device, - VkDynamicViewportState state)); + VkDynamicViewportState state); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDynamicRasterState( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDynamicRasterState, VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, - VkDynamicRasterState* pState)); + VkDynamicRasterState* pState); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDynamicRasterState( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDynamicRasterState, VkDevice device, - VkDynamicRasterState state)); + VkDynamicRasterState state); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDynamicColorBlendState( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDynamicColorBlendState, VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, - VkDynamicColorBlendState* pState)); + VkDynamicColorBlendState* pState); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDynamicColorBlendState( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDynamicColorBlendState, VkDevice device, - VkDynamicColorBlendState state)); + VkDynamicColorBlendState state); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDynamicDepthStencilState( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateDynamicDepthStencilState, VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, - VkDynamicDepthStencilState* pState)); + VkDynamicDepthStencilState* pState); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDynamicDepthStencilState( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyDynamicDepthStencilState, VkDevice device, - VkDynamicDepthStencilState state)); + VkDynamicDepthStencilState state); // Command pool functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateCommandPool( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateCommandPool, VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, - VkCmdPool* pCmdPool)); + VkCmdPool* pCmdPool); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyCommandPool( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyCommandPool, VkDevice device, - VkCmdPool VkCmdPool)); + VkCmdPool VkCmdPool); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkResetCommandPool( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkResetCommandPool, VkDevice device, VkCmdPool VkCmdPool, - VkCmdPoolResetFlags flags)); + VkCmdPoolResetFlags flags); // Command buffer functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateCommandBuffer( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateCommandBuffer, VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, - VkCmdBuffer* pCmdBuffer)); + VkCmdBuffer* pCmdBuffer); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyCommandBuffer( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyCommandBuffer, VkDevice device, - VkCmdBuffer cmdBuffer)); + VkCmdBuffer cmdBuffer); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkBeginCommandBuffer( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkBeginCommandBuffer, VkCmdBuffer cmdBuffer, - const VkCmdBufferBeginInfo* pBeginInfo)); + const VkCmdBufferBeginInfo* pBeginInfo); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkEndCommandBuffer( - VkCmdBuffer cmdBuffer)); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkEndCommandBuffer, + VkCmdBuffer cmdBuffer); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkResetCommandBuffer( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkResetCommandBuffer, VkCmdBuffer cmdBuffer, - VkCmdBufferResetFlags flags)); + VkCmdBufferResetFlags flags); // Command buffer building functions - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindPipeline( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindPipeline, VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline)); + VkPipeline pipeline); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDynamicViewportState( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDynamicViewportState, VkCmdBuffer cmdBuffer, - VkDynamicViewportState dynamicViewportState)); + VkDynamicViewportState dynamicViewportState); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDynamicRasterState( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDynamicRasterState, VkCmdBuffer cmdBuffer, - VkDynamicRasterState dynamicRasterState)); + VkDynamicRasterState dynamicRasterState); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDynamicColorBlendState( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDynamicColorBlendState, VkCmdBuffer cmdBuffer, - VkDynamicColorBlendState dynamicColorBlendState)); + VkDynamicColorBlendState dynamicColorBlendState); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDynamicDepthStencilState( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDynamicDepthStencilState, VkCmdBuffer cmdBuffer, - VkDynamicDepthStencilState dynamicDepthStencilState)); + VkDynamicDepthStencilState dynamicDepthStencilState); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDescriptorSets( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindDescriptorSets, VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, @@ -924,78 +936,78 @@ public: uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets)); + const uint32_t* pDynamicOffsets); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindIndexBuffer( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindIndexBuffer, VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, - VkIndexType indexType)); + VkIndexType indexType); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindVertexBuffers( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBindVertexBuffers, VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets)); + const VkDeviceSize* pOffsets); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDraw( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDraw, VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, - uint32_t instanceCount)); + uint32_t instanceCount); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDrawIndexed( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDrawIndexed, VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, - uint32_t instanceCount)); + uint32_t instanceCount); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDrawIndirect( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDrawIndirect, VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, - uint32_t stride)); + uint32_t stride); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDrawIndexedIndirect( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDrawIndexedIndirect, VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, - uint32_t stride)); + uint32_t stride); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDispatch( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDispatch, VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, - uint32_t z)); + uint32_t z); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDispatchIndirect( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDispatchIndirect, VkCmdBuffer cmdBuffer, VkBuffer buffer, - VkDeviceSize offset)); + VkDeviceSize offset); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyBuffer( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyBuffer, VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, - const VkBufferCopy* pRegions)); + const VkBufferCopy* pRegions); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyImage( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyImage, VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, - const VkImageCopy* pRegions)); + const VkImageCopy* pRegions); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBlitImage( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBlitImage, VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, @@ -1003,177 +1015,177 @@ public: VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, - VkTexFilter filter)); + VkTexFilter filter); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdResolveImage( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdResolveImage, VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, - const VkImageResolve* pRegions)); + const VkImageResolve* pRegions); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyBufferToImage( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyBufferToImage, VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, - const VkBufferImageCopy* pRegions)); + const VkBufferImageCopy* pRegions); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyImageToBuffer( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyImageToBuffer, VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, - const VkBufferImageCopy* pRegions)); + const VkBufferImageCopy* pRegions); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearColorImage( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearColorImage, VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, - const VkImageSubresourceRange* pRanges)); + const VkImageSubresourceRange* pRanges); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearDepthStencilImage( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearDepthStencilImage, VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, - const VkImageSubresourceRange* pRanges)); + const VkImageSubresourceRange* pRanges); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearColorAttachment( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearColorAttachment, VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, - const VkRect3D* pRects)); + const VkRect3D* pRects); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearDepthStencilAttachment( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdClearDepthStencilAttachment, VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rectCount, - const VkRect3D* pRects)); + const VkRect3D* pRects); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPipelineBarrier( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdPipelineBarrier, VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, - const void* const* ppMemBarriers)); + const void* const* ppMemBarriers); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBeginQuery( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBeginQuery, VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, - VkQueryControlFlags flags)); + VkQueryControlFlags flags); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdEndQuery( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdEndQuery, VkCmdBuffer cmdBuffer, VkQueryPool queryPool, - uint32_t slot)); + uint32_t slot); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdResetQueryPool( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdResetQueryPool, VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, - uint32_t queryCount)); + uint32_t queryCount); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateFramebuffer( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateFramebuffer, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, - VkFramebuffer* pFramebuffer)); + VkFramebuffer* pFramebuffer); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyFramebuffer( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyFramebuffer, VkDevice device, - VkFramebuffer framebuffer)); + VkFramebuffer framebuffer); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateRenderPass( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateRenderPass, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, - VkRenderPass* pRenderPass)); + VkRenderPass* pRenderPass); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyRenderPass( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyRenderPass, VkDevice device, - VkRenderPass renderPass)); + VkRenderPass renderPass); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBeginRenderPass( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBeginRenderPass, VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, - VkRenderPassContents contents)); + VkRenderPassContents contents); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdEndRenderPass( - VkCmdBuffer cmdBuffer)); + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdEndRenderPass, + VkCmdBuffer cmdBuffer); // Debug functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDbgCreateMsgCallback( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDbgCreateMsgCallback, VkInstance instance, VkFlags msgFlags, const PFN_vkDbgMsgCallback pfnMsgCallback, void* pUserData, - VkDbgMsgCallback* pMsgCallback)); + VkDbgMsgCallback* pMsgCallback); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDbgDestroyMsgCallback( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDbgDestroyMsgCallback, VkInstance instance, - VkDbgMsgCallback msgCallback)); + VkDbgMsgCallback msgCallback); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDbgMarkerBegin( + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDbgMarkerBegin, VkCmdBuffer cmdBuffer, - const char* pMarker)); + const char* pMarker); - IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDbgMarkerEnd( - VkCmdBuffer cmdBuffer)); + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDbgMarkerEnd, + VkCmdBuffer cmdBuffer); // WSI functions - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceSurfaceSupportWSI( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetPhysicalDeviceSurfaceSupportWSI, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkSurfaceDescriptionWSI* pSurfaceDescription, - VkBool32* pSupported)); + VkBool32* pSupported); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateSwapChainWSI( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateSwapChainWSI, VkDevice device, const VkSwapChainCreateInfoWSI* pCreateInfo, - VkSwapChainWSI* pSwapChain)); + VkSwapChainWSI* pSwapChain); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroySwapChainWSI( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroySwapChainWSI, VkDevice device, - VkSwapChainWSI swapChain)); + VkSwapChainWSI swapChain); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetSurfaceInfoWSI( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetSurfaceInfoWSI, VkDevice device, const VkSurfaceDescriptionWSI* pSurfaceDescription, VkSurfaceInfoTypeWSI infoType, size_t* pDataSize, - void* pData)); + void* pData); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetSwapChainInfoWSI( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetSwapChainInfoWSI, VkDevice device, VkSwapChainWSI swapChain, VkSwapChainInfoTypeWSI infoType, size_t* pDataSize, - void* pData)); + void* pData); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAcquireNextImageWSI( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkAcquireNextImageWSI, VkDevice device, VkSwapChainWSI swapChain, uint64_t timeout, VkSemaphore semaphore, - uint32_t* pImageIndex)); + uint32_t* pImageIndex); - IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueuePresentWSI( + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkQueuePresentWSI, VkQueue queue, - VkPresentInfoWSI* pPresentInfo)); + VkPresentInfoWSI* pPresentInfo); }; diff --git a/renderdoc/driver/vulkan/vk_initstate.cpp b/renderdoc/driver/vulkan/vk_initstate.cpp index b59f8bf04..52255b5b9 100644 --- a/renderdoc/driver/vulkan/vk_initstate.cpp +++ b/renderdoc/driver/vulkan/vk_initstate.cpp @@ -156,6 +156,9 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res) bool WrappedVulkan::Serialise_InitialState(WrappedVkRes *res) { + // use same serialiser as resource manager + Serialiser *localSerialiser = GetMainSerialiser(); + SERIALISE_ELEMENT(VkResourceType, type, IdentifyTypeByPtr(res)); SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(res)); diff --git a/renderdoc/driver/vulkan/vk_manager.cpp b/renderdoc/driver/vulkan/vk_manager.cpp index d7c481308..45cbd3076 100644 --- a/renderdoc/driver/vulkan/vk_manager.cpp +++ b/renderdoc/driver/vulkan/vk_manager.cpp @@ -207,6 +207,8 @@ void VulkanResourceManager::RecordTransitions(vector< pair &states, vector &transitions) { + Serialiser *localSerialiser = m_pSerialiser; + SERIALISE_ELEMENT(uint32_t, NumMems, (uint32_t)states.size()); auto srcit = states.begin(); diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index 577dafc5f..957b0a17f 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/renderdoc/driver/vulkan/vk_replay.cpp @@ -451,17 +451,17 @@ ResourceId VulkanReplay::GetLiveID(ResourceId id) void VulkanReplay::InitCallstackResolver() { - m_pDriver->GetSerialiser()->InitCallstackResolver(); + m_pDriver->GetMainSerialiser()->InitCallstackResolver(); } bool VulkanReplay::HasCallstacks() { - return m_pDriver->GetSerialiser()->HasCallstacks(); + return m_pDriver->GetMainSerialiser()->HasCallstacks(); } Callstack::StackResolver *VulkanReplay::GetCallstackResolver() { - return m_pDriver->GetSerialiser()->GetCallstackResolver(); + return m_pDriver->GetMainSerialiser()->GetCallstackResolver(); } vector VulkanReplay::GetFrameRecord() diff --git a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp index b5f7611d3..86285e0d0 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp @@ -27,6 +27,7 @@ // Command pool functions bool WrappedVulkan::Serialise_vkCreateCommandPool( + Serialiser* localSerialiser, VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool) @@ -70,10 +71,12 @@ VkResult WrappedVulkan::vkCreateCommandPool( if(m_State >= WRITING) { Chunk *chunk = NULL; - + { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_CMD_POOL); - Serialise_vkCreateCommandPool(device, pCreateInfo, pCmdPool); + Serialise_vkCreateCommandPool(localSerialiser, device, pCreateInfo, pCmdPool); chunk = scope.Get(); } @@ -139,6 +142,7 @@ VkResult WrappedVulkan::vkCreateCommandBuffer( } bool WrappedVulkan::Serialise_vkBeginCommandBuffer( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) { @@ -173,7 +177,7 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer( } SERIALISE_ELEMENT(ResourceId, devId, GetResID(device)); - GetSerialiser()->Serialise("createInfo", createInfo); + localSerialiser->Serialise("createInfo", createInfo); if(m_State < WRITING) device = GetResourceManager()->GetLiveHandle(devId); @@ -281,8 +285,10 @@ VkResult WrappedVulkan::vkBeginCommandBuffer( record->bakedCommands = GetResourceManager()->AddResourceRecord(ResourceIDGen::GetNewUniqueID()); { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BEGIN_CMD_BUFFER); - Serialise_vkBeginCommandBuffer(cmdBuffer, pBeginInfo); + Serialise_vkBeginCommandBuffer(localSerialiser, cmdBuffer, pBeginInfo); record->AddChunk(scope.Get()); } @@ -295,7 +301,7 @@ VkResult WrappedVulkan::vkBeginCommandBuffer( return ObjDisp(cmdBuffer)->BeginCommandBuffer(Unwrap(cmdBuffer), &unwrappedInfo); } -bool WrappedVulkan::Serialise_vkEndCommandBuffer(VkCmdBuffer cmdBuffer) +bool WrappedVulkan::Serialise_vkEndCommandBuffer(Serialiser* localSerialiser, VkCmdBuffer cmdBuffer) { SERIALISE_ELEMENT(ResourceId, cmdId, GetResID(cmdBuffer)); @@ -389,8 +395,10 @@ VkResult WrappedVulkan::vkEndCommandBuffer(VkCmdBuffer cmdBuffer) RDCASSERT(record->bakedCommands); { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(END_CMD_BUFFER); - Serialise_vkEndCommandBuffer(cmdBuffer); + Serialise_vkEndCommandBuffer(localSerialiser, cmdBuffer); record->AddChunk(scope.Get()); } @@ -401,7 +409,7 @@ VkResult WrappedVulkan::vkEndCommandBuffer(VkCmdBuffer cmdBuffer) return ObjDisp(cmdBuffer)->EndCommandBuffer(Unwrap(cmdBuffer)); } -bool WrappedVulkan::Serialise_vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) +bool WrappedVulkan::Serialise_vkResetCommandBuffer(Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) { SERIALISE_ELEMENT(ResourceId, cmdId, GetResID(cmdBuffer)); SERIALISE_ELEMENT(VkCmdBufferResetFlags, fl, flags); @@ -428,7 +436,7 @@ bool WrappedVulkan::Serialise_vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdB } SERIALISE_ELEMENT(ResourceId, devId, GetResID(device)); - GetSerialiser()->Serialise("createInfo", info); + localSerialiser->Serialise("createInfo", info); if(m_State == EXECUTING) { @@ -488,8 +496,10 @@ VkResult WrappedVulkan::vkResetCommandBuffer( // serialising this (as we never re-begin a cmd buffer, we make a new copy // for each bake). { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(RESET_CMD_BUFFER); - Serialise_vkResetCommandBuffer(cmdBuffer, flags); + Serialise_vkResetCommandBuffer(localSerialiser, cmdBuffer, flags); record->AddChunk(scope.Get()); } @@ -501,6 +511,7 @@ VkResult WrappedVulkan::vkResetCommandBuffer( // Command buffer building functions bool WrappedVulkan::Serialise_vkCmdBeginRenderPass( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) @@ -532,7 +543,7 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass( ObjDisp(cmdBuffer)->CmdBeginRenderPass(Unwrap(cmdBuffer), &beginInfo, cont); - const string desc = GetSerialiser()->GetDebugStr(); + const string desc = localSerialiser->GetDebugStr(); // VKTODOMED change the name to show render pass load-op AddEvent(BEGIN_RENDERPASS, desc); @@ -560,8 +571,10 @@ void WrappedVulkan::vkCmdBeginRenderPass( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BEGIN_RENDERPASS); - Serialise_vkCmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents); + Serialise_vkCmdBeginRenderPass(localSerialiser, cmdBuffer, pRenderPassBegin, contents); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(pRenderPassBegin->renderPass), eFrameRef_Read); @@ -571,6 +584,7 @@ void WrappedVulkan::vkCmdBeginRenderPass( } bool WrappedVulkan::Serialise_vkCmdEndRenderPass( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer) { SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); @@ -611,14 +625,17 @@ void WrappedVulkan::vkCmdEndRenderPass( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(END_RENDERPASS); - Serialise_vkCmdEndRenderPass(cmdBuffer); + Serialise_vkCmdEndRenderPass(localSerialiser, cmdBuffer); record->AddChunk(scope.Get()); } } bool WrappedVulkan::Serialise_vkCmdBindPipeline( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) @@ -672,8 +689,10 @@ void WrappedVulkan::vkCmdBindPipeline( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BIND_PIPELINE); - Serialise_vkCmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); + Serialise_vkCmdBindPipeline(localSerialiser, cmdBuffer, pipelineBindPoint, pipeline); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(pipeline), eFrameRef_Read); @@ -681,6 +700,7 @@ void WrappedVulkan::vkCmdBindPipeline( } bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, @@ -709,7 +729,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets( for(uint32_t i=0; i < numSets; i++) { if(m_State >= WRITING) descriptorIDs[i] = GetResID(sets[i]); - GetSerialiser()->Serialise("DescriptorSet", descriptorIDs[i]); + localSerialiser->Serialise("DescriptorSet", descriptorIDs[i]); if(m_State < WRITING) sets[i] = Unwrap(GetResourceManager()->GetLiveHandle(descriptorIDs[i])); } @@ -813,8 +833,10 @@ void WrappedVulkan::vkCmdBindDescriptorSets( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BIND_DESCRIPTOR_SET); - Serialise_vkCmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); + Serialise_vkCmdBindDescriptorSets(localSerialiser, cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(layout), eFrameRef_Read); @@ -823,6 +845,7 @@ void WrappedVulkan::vkCmdBindDescriptorSets( } bool WrappedVulkan::Serialise_vkCmdBindDynamicViewportState( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState) { @@ -865,8 +888,10 @@ void WrappedVulkan::vkCmdBindDynamicViewportState( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BIND_VP_STATE); - Serialise_vkCmdBindDynamicViewportState(cmdBuffer, dynamicViewportState); + Serialise_vkCmdBindDynamicViewportState(localSerialiser, cmdBuffer, dynamicViewportState); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(dynamicViewportState), eFrameRef_Read); @@ -874,6 +899,7 @@ void WrappedVulkan::vkCmdBindDynamicViewportState( } bool WrappedVulkan::Serialise_vkCmdBindDynamicRasterState( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState) { @@ -916,8 +942,10 @@ void WrappedVulkan::vkCmdBindDynamicRasterState( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BIND_RS_STATE); - Serialise_vkCmdBindDynamicRasterState(cmdBuffer, dynamicRasterState); + Serialise_vkCmdBindDynamicRasterState(localSerialiser, cmdBuffer, dynamicRasterState); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(dynamicRasterState), eFrameRef_Read); @@ -925,6 +953,7 @@ void WrappedVulkan::vkCmdBindDynamicRasterState( } bool WrappedVulkan::Serialise_vkCmdBindDynamicColorBlendState( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) { @@ -966,8 +995,10 @@ void WrappedVulkan::vkCmdBindDynamicColorBlendState( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BIND_CB_STATE); - Serialise_vkCmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState); + Serialise_vkCmdBindDynamicColorBlendState(localSerialiser, cmdBuffer, dynamicColorBlendState); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(dynamicColorBlendState), eFrameRef_Read); @@ -975,6 +1006,7 @@ void WrappedVulkan::vkCmdBindDynamicColorBlendState( } bool WrappedVulkan::Serialise_vkCmdBindDynamicDepthStencilState( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState) { @@ -1016,8 +1048,10 @@ void WrappedVulkan::vkCmdBindDynamicDepthStencilState( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BIND_DS_STATE); - Serialise_vkCmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState); + Serialise_vkCmdBindDynamicDepthStencilState(localSerialiser, cmdBuffer, dynamicDepthStencilState); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(dynamicDepthStencilState), eFrameRef_Read); @@ -1025,6 +1059,7 @@ void WrappedVulkan::vkCmdBindDynamicDepthStencilState( } bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, @@ -1052,8 +1087,8 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers( o = pOffsets[i]; } - GetSerialiser()->Serialise("pBuffers[]", id); - GetSerialiser()->Serialise("pOffsets[]", o); + localSerialiser->Serialise("pBuffers[]", id); + localSerialiser->Serialise("pOffsets[]", o); if(m_State < WRITING) { @@ -1111,8 +1146,10 @@ void WrappedVulkan::vkCmdBindVertexBuffers( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BIND_VERTEX_BUFFERS); - Serialise_vkCmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets); + Serialise_vkCmdBindVertexBuffers(localSerialiser, cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets); record->AddChunk(scope.Get()); for(uint32_t i=0; i < bindingCount; i++) @@ -1122,6 +1159,7 @@ void WrappedVulkan::vkCmdBindVertexBuffers( bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, @@ -1175,8 +1213,10 @@ void WrappedVulkan::vkCmdBindIndexBuffer( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BIND_INDEX_BUFFER); - Serialise_vkCmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); + Serialise_vkCmdBindIndexBuffer(localSerialiser, cmdBuffer, buffer, offset, indexType); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(buffer), eFrameRef_Read); @@ -1184,6 +1224,7 @@ void WrappedVulkan::vkCmdBindIndexBuffer( } bool WrappedVulkan::Serialise_vkCmdPipelineBarrier( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, @@ -1316,8 +1357,10 @@ void WrappedVulkan::vkCmdPipelineBarrier( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(PIPELINE_BARRIER); - Serialise_vkCmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers); + Serialise_vkCmdPipelineBarrier(localSerialiser, cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers); record->AddChunk(scope.Get()); @@ -1340,6 +1383,7 @@ void WrappedVulkan::vkCmdPipelineBarrier( } bool WrappedVulkan::Serialise_vkCmdBeginQuery( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, @@ -1386,8 +1430,10 @@ void WrappedVulkan::vkCmdBeginQuery( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BEGIN_QUERY); - Serialise_vkCmdBeginQuery(cmdBuffer, queryPool, slot, flags); + Serialise_vkCmdBeginQuery(localSerialiser, cmdBuffer, queryPool, slot, flags); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(queryPool), eFrameRef_Read); @@ -1395,6 +1441,7 @@ void WrappedVulkan::vkCmdBeginQuery( } bool WrappedVulkan::Serialise_vkCmdEndQuery( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) @@ -1438,8 +1485,10 @@ void WrappedVulkan::vkCmdEndQuery( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(END_QUERY); - Serialise_vkCmdEndQuery(cmdBuffer, queryPool, slot); + Serialise_vkCmdEndQuery(localSerialiser, cmdBuffer, queryPool, slot); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(queryPool), eFrameRef_Read); @@ -1447,6 +1496,7 @@ void WrappedVulkan::vkCmdEndQuery( } bool WrappedVulkan::Serialise_vkCmdResetQueryPool( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, @@ -1493,8 +1543,10 @@ void WrappedVulkan::vkCmdResetQueryPool( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(RESET_QUERY_POOL); - Serialise_vkCmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); + Serialise_vkCmdResetQueryPool(localSerialiser, cmdBuffer, queryPool, startQuery, queryCount); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(queryPool), eFrameRef_Read); @@ -1502,6 +1554,7 @@ void WrappedVulkan::vkCmdResetQueryPool( } bool WrappedVulkan::Serialise_vkCmdDbgMarkerBegin( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, const char* pMarker) { @@ -1531,14 +1584,16 @@ void WrappedVulkan::vkCmdDbgMarkerBegin( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BEGIN_EVENT); - Serialise_vkCmdDbgMarkerBegin(cmdBuffer, pMarker); + Serialise_vkCmdDbgMarkerBegin(localSerialiser, cmdBuffer, pMarker); record->AddChunk(scope.Get()); } } -bool WrappedVulkan::Serialise_vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer) +bool WrappedVulkan::Serialise_vkCmdDbgMarkerEnd(Serialiser* localSerialiser, VkCmdBuffer cmdBuffer) { SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); @@ -1564,8 +1619,10 @@ void WrappedVulkan::vkCmdDbgMarkerEnd( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(END_EVENT); - Serialise_vkCmdDbgMarkerEnd(cmdBuffer); + Serialise_vkCmdDbgMarkerEnd(localSerialiser, cmdBuffer); record->AddChunk(scope.Get()); } diff --git a/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp index 070358531..f06f1f74c 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_descriptor_funcs.cpp @@ -25,6 +25,7 @@ #include "../vk_core.h" bool WrappedVulkan::Serialise_vkCreateDescriptorPool( + Serialiser* localSerialiser, VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, @@ -77,8 +78,10 @@ VkResult WrappedVulkan::vkCreateDescriptorPool( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_DESCRIPTOR_POOL); - Serialise_vkCreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); + Serialise_vkCreateDescriptorPool(localSerialiser, device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); chunk = scope.Get(); } @@ -96,6 +99,7 @@ VkResult WrappedVulkan::vkCreateDescriptorPool( } bool WrappedVulkan::Serialise_vkCreateDescriptorSetLayout( + Serialiser* localSerialiser, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) @@ -168,8 +172,10 @@ VkResult WrappedVulkan::vkCreateDescriptorSetLayout( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_DESCRIPTOR_SET_LAYOUT); - Serialise_vkCreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); + Serialise_vkCreateDescriptorSetLayout(localSerialiser, device, pCreateInfo, pSetLayout); chunk = scope.Get(); } @@ -186,6 +192,7 @@ VkResult WrappedVulkan::vkCreateDescriptorSetLayout( return ret; } bool WrappedVulkan::Serialise_vkAllocDescriptorSets( + Serialiser* localSerialiser, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, @@ -261,8 +268,10 @@ VkResult WrappedVulkan::vkAllocDescriptorSets( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(ALLOC_DESC_SET); - Serialise_vkAllocDescriptorSets(device, descriptorPool, setUsage, 1, &pSetLayouts[i], &pDescriptorSets[i], NULL); + Serialise_vkAllocDescriptorSets(localSerialiser, device, descriptorPool, setUsage, 1, &pSetLayouts[i], &pDescriptorSets[i], NULL); chunk = scope.Get(); } @@ -317,6 +326,7 @@ VkResult WrappedVulkan::vkFreeDescriptorSets( } bool WrappedVulkan::Serialise_vkUpdateDescriptorSets( + Serialiser* localSerialiser, VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, @@ -491,8 +501,10 @@ VkResult WrappedVulkan::vkUpdateDescriptorSets( for(uint32_t i=0; i < writeCount; i++) { { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(UPDATE_DESC_SET); - Serialise_vkUpdateDescriptorSets(device, 1, &pDescriptorWrites[i], 0, NULL); + Serialise_vkUpdateDescriptorSets(localSerialiser, device, 1, &pDescriptorWrites[i], 0, NULL); m_FrameCaptureRecord->AddChunk(scope.Get()); } @@ -505,8 +517,10 @@ VkResult WrappedVulkan::vkUpdateDescriptorSets( for(uint32_t i=0; i < copyCount; i++) { { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(UPDATE_DESC_SET); - Serialise_vkUpdateDescriptorSets(device, 0, NULL, 1, &pDescriptorCopies[i]); + Serialise_vkUpdateDescriptorSets(localSerialiser, device, 0, NULL, 1, &pDescriptorCopies[i]); m_FrameCaptureRecord->AddChunk(scope.Get()); } diff --git a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp index 05d1d0f56..24d3a1037 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp @@ -89,6 +89,7 @@ VkResult WrappedVulkan::vkDestroyInstance( } bool WrappedVulkan::Serialise_vkEnumeratePhysicalDevices( + Serialiser* localSerialiser, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) @@ -175,8 +176,10 @@ VkResult WrappedVulkan::vkEnumeratePhysicalDevices( if(m_State >= WRITING) { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(ENUM_PHYSICALS); - Serialise_vkEnumeratePhysicalDevices(instance, &i, &devices[i]); + Serialise_vkEnumeratePhysicalDevices(localSerialiser, instance, &i, &devices[i]); m_InstanceRecord->AddChunk(scope.Get()); } @@ -192,6 +195,7 @@ VkResult WrappedVulkan::vkEnumeratePhysicalDevices( } bool WrappedVulkan::Serialise_vkCreateDevice( + Serialiser* localSerialiser, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) @@ -410,8 +414,10 @@ VkResult WrappedVulkan::vkCreateDevice( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_DEVICE); - Serialise_vkCreateDevice(physicalDevice, &createInfo, pDevice); + Serialise_vkCreateDevice(localSerialiser, physicalDevice, &createInfo, pDevice); chunk = scope.Get(); } @@ -505,7 +511,7 @@ VkResult WrappedVulkan::vkDestroyDevice(VkDevice device) return ret; } -bool WrappedVulkan::Serialise_vkDeviceWaitIdle(VkDevice device) +bool WrappedVulkan::Serialise_vkDeviceWaitIdle(Serialiser* localSerialiser, VkDevice device) { SERIALISE_ELEMENT(ResourceId, id, GetResID(device)); @@ -524,8 +530,10 @@ VkResult WrappedVulkan::vkDeviceWaitIdle(VkDevice device) if(m_State >= WRITING_CAPFRAME) { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(DEVICE_WAIT_IDLE); - Serialise_vkDeviceWaitIdle(device); + Serialise_vkDeviceWaitIdle(localSerialiser, device); m_FrameCaptureRecord->AddChunk(scope.Get()); } diff --git a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp index dc6de187f..3a160ff6a 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp @@ -25,6 +25,7 @@ #include "../vk_core.h" bool WrappedVulkan::Serialise_vkCmdDraw( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, @@ -54,7 +55,7 @@ bool WrappedVulkan::Serialise_vkCmdDraw( ObjDisp(cmdBuffer)->CmdDraw(Unwrap(cmdBuffer), firstVtx, vtxCount, firstInst, instCount); - const string desc = GetSerialiser()->GetDebugStr(); + const string desc = localSerialiser->GetDebugStr(); { AddEvent(DRAW, desc); @@ -92,14 +93,17 @@ void WrappedVulkan::vkCmdDraw( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(DRAW); - Serialise_vkCmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); + Serialise_vkCmdDraw(localSerialiser, cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); record->AddChunk(scope.Get()); } } bool WrappedVulkan::Serialise_vkCmdBlitImage( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, @@ -164,8 +168,10 @@ void WrappedVulkan::vkCmdBlitImage( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BLIT_IMG); - Serialise_vkCmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter); + Serialise_vkCmdBlitImage(localSerialiser, cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter); record->AddChunk(scope.Get()); @@ -181,6 +187,7 @@ void WrappedVulkan::vkCmdBlitImage( } bool WrappedVulkan::Serialise_vkCmdResolveImage( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, @@ -241,8 +248,10 @@ void WrappedVulkan::vkCmdResolveImage( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(RESOLVE_IMG); - Serialise_vkCmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); + Serialise_vkCmdResolveImage(localSerialiser, cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); record->AddChunk(scope.Get()); @@ -258,6 +267,7 @@ void WrappedVulkan::vkCmdResolveImage( } bool WrappedVulkan::Serialise_vkCmdCopyImage( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, @@ -317,9 +327,11 @@ void WrappedVulkan::vkCmdCopyImage( if(m_State >= WRITING) { VkResourceRecord *record = GetRecord(cmdBuffer); + + CACHE_THREAD_SERIALISER(); SCOPED_SERIALISE_CONTEXT(COPY_IMG); - Serialise_vkCmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); + Serialise_vkCmdCopyImage(localSerialiser, cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(srcImage), eFrameRef_Read); @@ -335,6 +347,7 @@ void WrappedVulkan::vkCmdCopyImage( } bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, @@ -371,7 +384,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage( ObjDisp(cmdBuffer)->CmdCopyBufferToImage(Unwrap(cmdBuffer), Unwrap(srcBuffer), Unwrap(destImage), destImageLayout, count, regions); - const string desc = GetSerialiser()->GetDebugStr(); + const string desc = localSerialiser->GetDebugStr(); { AddEvent(COPY_BUF2IMG, desc); @@ -406,8 +419,10 @@ void WrappedVulkan::vkCmdCopyBufferToImage( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(COPY_BUF2IMG); - Serialise_vkCmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); + Serialise_vkCmdCopyBufferToImage(localSerialiser, cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); record->AddChunk(scope.Get()); @@ -423,6 +438,7 @@ void WrappedVulkan::vkCmdCopyBufferToImage( } bool WrappedVulkan::Serialise_vkCmdCopyImageToBuffer( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, @@ -481,8 +497,10 @@ void WrappedVulkan::vkCmdCopyImageToBuffer( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(COPY_IMG2BUF); - Serialise_vkCmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); + Serialise_vkCmdCopyImageToBuffer(localSerialiser, cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(srcImage), eFrameRef_Read); @@ -498,6 +516,7 @@ void WrappedVulkan::vkCmdCopyImageToBuffer( } bool WrappedVulkan::Serialise_vkCmdCopyBuffer( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, @@ -533,7 +552,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyBuffer( ObjDisp(cmdBuffer)->CmdCopyBuffer(Unwrap(cmdBuffer), Unwrap(srcBuffer), Unwrap(destBuffer), count, regions); - const string desc = GetSerialiser()->GetDebugStr(); + const string desc = localSerialiser->GetDebugStr(); { AddEvent(COPY_BUF, desc); @@ -567,8 +586,10 @@ void WrappedVulkan::vkCmdCopyBuffer( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(COPY_BUF); - Serialise_vkCmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); + Serialise_vkCmdCopyBuffer(localSerialiser, cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(srcBuffer), eFrameRef_Read); @@ -584,6 +605,7 @@ void WrappedVulkan::vkCmdCopyBuffer( } bool WrappedVulkan::Serialise_vkCmdClearColorImage( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, @@ -639,8 +661,10 @@ void WrappedVulkan::vkCmdClearColorImage( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CLEAR_COLOR); - Serialise_vkCmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges); + Serialise_vkCmdClearColorImage(localSerialiser, cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(image), eFrameRef_Write); @@ -648,6 +672,7 @@ void WrappedVulkan::vkCmdClearColorImage( } bool WrappedVulkan::Serialise_vkCmdClearDepthStencilImage( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, @@ -705,8 +730,10 @@ void WrappedVulkan::vkCmdClearDepthStencilImage( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CLEAR_DEPTHSTENCIL); - Serialise_vkCmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); + Serialise_vkCmdClearDepthStencilImage(localSerialiser, cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); record->AddChunk(scope.Get()); record->MarkResourceFrameReferenced(GetResID(image), eFrameRef_Write); @@ -714,6 +741,7 @@ void WrappedVulkan::vkCmdClearDepthStencilImage( } bool WrappedVulkan::Serialise_vkCmdClearColorAttachment( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, @@ -746,7 +774,7 @@ bool WrappedVulkan::Serialise_vkCmdClearColorAttachment( ObjDisp(cmdBuffer)->CmdClearColorAttachment(Unwrap(cmdBuffer), att, layout, &col, count, rects); - const string desc = GetSerialiser()->GetDebugStr(); + const string desc = localSerialiser->GetDebugStr(); { AddEvent(CLEAR_COLOR_ATTACH, desc); @@ -781,8 +809,10 @@ void WrappedVulkan::vkCmdClearColorAttachment( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CLEAR_COLOR_ATTACH); - Serialise_vkCmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects); + Serialise_vkCmdClearColorAttachment(localSerialiser, cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects); record->AddChunk(scope.Get()); // VKTODOHIGH mark referenced the image under the attachment @@ -791,6 +821,7 @@ void WrappedVulkan::vkCmdClearColorAttachment( } bool WrappedVulkan::Serialise_vkCmdClearDepthStencilAttachment( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, @@ -824,7 +855,7 @@ bool WrappedVulkan::Serialise_vkCmdClearDepthStencilAttachment( ObjDisp(cmdBuffer)->CmdClearDepthStencilAttachment(Unwrap(cmdBuffer), asp, lay, d, s, count, rects); - const string desc = GetSerialiser()->GetDebugStr(); + const string desc = localSerialiser->GetDebugStr(); { AddEvent(CLEAR_DEPTHSTENCIL_ATTACH, desc); @@ -860,8 +891,10 @@ void WrappedVulkan::vkCmdClearDepthStencilAttachment( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CLEAR_DEPTHSTENCIL_ATTACH); - Serialise_vkCmdClearDepthStencilAttachment(cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects); + Serialise_vkCmdClearDepthStencilAttachment(localSerialiser, cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects); record->AddChunk(scope.Get()); // VKTODOHIGH mark referenced the image under the attachment @@ -870,6 +903,7 @@ void WrappedVulkan::vkCmdClearDepthStencilAttachment( } bool WrappedVulkan::Serialise_vkCmdDrawIndexed( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, @@ -901,7 +935,7 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexed( ObjDisp(cmdBuffer)->CmdDrawIndexed(Unwrap(cmdBuffer), firstIdx, idxCount, vtxOffs, firstInst, instCount); - const string desc = GetSerialiser()->GetDebugStr(); + const string desc = localSerialiser->GetDebugStr(); { AddEvent(DRAW_INDEXED, desc); @@ -940,14 +974,17 @@ void WrappedVulkan::vkCmdDrawIndexed( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(DRAW_INDEXED); - Serialise_vkCmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); + Serialise_vkCmdDrawIndexed(localSerialiser, cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); record->AddChunk(scope.Get()); } } bool WrappedVulkan::Serialise_vkCmdDrawIndirect( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, @@ -998,14 +1035,17 @@ void WrappedVulkan::vkCmdDrawIndirect( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(DRAW_INDIRECT); - Serialise_vkCmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); + Serialise_vkCmdDrawIndirect(localSerialiser, cmdBuffer, buffer, offset, count, stride); record->AddChunk(scope.Get()); } } bool WrappedVulkan::Serialise_vkCmdDrawIndexedIndirect( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, @@ -1056,14 +1096,17 @@ void WrappedVulkan::vkCmdDrawIndexedIndirect( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(DRAW_INDEXED_INDIRECT); - Serialise_vkCmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); + Serialise_vkCmdDrawIndexedIndirect(localSerialiser, cmdBuffer, buffer, offset, count, stride); record->AddChunk(scope.Get()); } } bool WrappedVulkan::Serialise_vkCmdDispatch( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, @@ -1107,14 +1150,17 @@ void WrappedVulkan::vkCmdDispatch( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(DISPATCH); - Serialise_vkCmdDispatch(cmdBuffer, x, y, z); + Serialise_vkCmdDispatch(localSerialiser, cmdBuffer, x, y, z); record->AddChunk(scope.Get()); } } bool WrappedVulkan::Serialise_vkCmdDispatchIndirect( + Serialiser* localSerialiser, VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) @@ -1158,8 +1204,10 @@ void WrappedVulkan::vkCmdDispatchIndirect( { VkResourceRecord *record = GetRecord(cmdBuffer); + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(DISPATCH_INDIRECT); - Serialise_vkCmdDispatchIndirect(cmdBuffer, buffer, offset); + Serialise_vkCmdDispatchIndirect(localSerialiser, cmdBuffer, buffer, offset); record->AddChunk(scope.Get()); } diff --git a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp index 2e8afc070..31fdca71d 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp @@ -217,6 +217,7 @@ bool WrappedVulkan::ReleaseResource(WrappedVkRes *res) // Sampler functions bool WrappedVulkan::Serialise_vkCreateSampler( + Serialiser* localSerialiser, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) @@ -262,8 +263,10 @@ VkResult WrappedVulkan::vkCreateSampler( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_SAMPLER); - Serialise_vkCreateSampler(device, pCreateInfo, pSampler); + Serialise_vkCreateSampler(localSerialiser, device, pCreateInfo, pSampler); chunk = scope.Get(); } @@ -281,6 +284,7 @@ VkResult WrappedVulkan::vkCreateSampler( } bool WrappedVulkan::Serialise_vkCreateSemaphore( + Serialiser* localSerialiser, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) @@ -326,8 +330,10 @@ VkResult WrappedVulkan::vkCreateSemaphore( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_SEMAPHORE); - Serialise_vkCreateSemaphore(device, pCreateInfo, pSemaphore); + Serialise_vkCreateSemaphore(localSerialiser, device, pCreateInfo, pSemaphore); chunk = scope.Get(); } @@ -345,6 +351,7 @@ VkResult WrappedVulkan::vkCreateSemaphore( } bool WrappedVulkan::Serialise_vkCreateFramebuffer( + Serialiser* localSerialiser, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) @@ -378,6 +385,7 @@ bool WrappedVulkan::Serialise_vkCreateFramebuffer( } bool WrappedVulkan::Serialise_vkCreateFence( + Serialiser* localSerialiser, VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) @@ -423,8 +431,10 @@ VkResult WrappedVulkan::vkCreateFence( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_FENCE); - Serialise_vkCreateFence(device, pCreateInfo, pFence); + Serialise_vkCreateFence(localSerialiser, device, pCreateInfo, pFence); chunk = scope.Get(); } @@ -442,6 +452,7 @@ VkResult WrappedVulkan::vkCreateFence( } bool WrappedVulkan::Serialise_vkGetFenceStatus( + Serialiser* localSerialiser, VkDevice device, VkFence fence) { @@ -468,8 +479,10 @@ VkResult WrappedVulkan::vkGetFenceStatus( if(m_State >= WRITING_CAPFRAME) { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(GET_FENCE_STATUS); - Serialise_vkGetFenceStatus(device, fence); + Serialise_vkGetFenceStatus(localSerialiser, device, fence); m_FrameCaptureRecord->AddChunk(scope.Get()); } @@ -508,8 +521,10 @@ VkResult WrappedVulkan::vkCreateFramebuffer( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_FRAMEBUFFER); - Serialise_vkCreateFramebuffer(device, pCreateInfo, pFramebuffer); + Serialise_vkCreateFramebuffer(localSerialiser, device, pCreateInfo, pFramebuffer); chunk = scope.Get(); } @@ -534,6 +549,7 @@ VkResult WrappedVulkan::vkCreateFramebuffer( } bool WrappedVulkan::Serialise_vkCreateRenderPass( + Serialiser* localSerialiser, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) @@ -582,8 +598,10 @@ VkResult WrappedVulkan::vkCreateRenderPass( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_RENDERPASS); - Serialise_vkCreateRenderPass(device, pCreateInfo, pRenderPass); + Serialise_vkCreateRenderPass(localSerialiser, device, pCreateInfo, pRenderPass); chunk = scope.Get(); } @@ -603,6 +621,7 @@ VkResult WrappedVulkan::vkCreateRenderPass( // State object functions bool WrappedVulkan::Serialise_vkCreateDynamicViewportState( + Serialiser* localSerialiser, VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState) @@ -651,8 +670,10 @@ VkResult WrappedVulkan::vkCreateDynamicViewportState( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_VIEWPORT_STATE); - Serialise_vkCreateDynamicViewportState(device, pCreateInfo, pState); + Serialise_vkCreateDynamicViewportState(localSerialiser, device, pCreateInfo, pState); chunk = scope.Get(); } @@ -670,6 +691,7 @@ VkResult WrappedVulkan::vkCreateDynamicViewportState( } bool WrappedVulkan::Serialise_vkCreateDynamicRasterState( + Serialiser* localSerialiser, VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState) @@ -718,8 +740,10 @@ VkResult WrappedVulkan::vkCreateDynamicRasterState( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_RASTER_STATE); - Serialise_vkCreateDynamicRasterState(device, pCreateInfo, pState); + Serialise_vkCreateDynamicRasterState(localSerialiser, device, pCreateInfo, pState); chunk = scope.Get(); } @@ -737,6 +761,7 @@ VkResult WrappedVulkan::vkCreateDynamicRasterState( } bool WrappedVulkan::Serialise_vkCreateDynamicColorBlendState( + Serialiser* localSerialiser, VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) @@ -785,8 +810,10 @@ VkResult WrappedVulkan::vkCreateDynamicColorBlendState( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_BLEND_STATE); - Serialise_vkCreateDynamicColorBlendState(device, pCreateInfo, pState); + Serialise_vkCreateDynamicColorBlendState(localSerialiser, device, pCreateInfo, pState); chunk = scope.Get(); } @@ -804,6 +831,7 @@ VkResult WrappedVulkan::vkCreateDynamicColorBlendState( } bool WrappedVulkan::Serialise_vkCreateDynamicDepthStencilState( + Serialiser* localSerialiser, VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState) @@ -852,8 +880,10 @@ VkResult WrappedVulkan::vkCreateDynamicDepthStencilState( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_DEPTH_STATE); - Serialise_vkCreateDynamicDepthStencilState(device, pCreateInfo, pState); + Serialise_vkCreateDynamicDepthStencilState(localSerialiser, device, pCreateInfo, pState); chunk = scope.Get(); } @@ -871,6 +901,7 @@ VkResult WrappedVulkan::vkCreateDynamicDepthStencilState( } bool WrappedVulkan::Serialise_vkCreateQueryPool( + Serialiser* localSerialiser, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) @@ -916,8 +947,10 @@ VkResult WrappedVulkan::vkCreateQueryPool( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_QUERY_POOL); - Serialise_vkCreateQueryPool(device, pCreateInfo, pQueryPool); + Serialise_vkCreateQueryPool(localSerialiser, device, pCreateInfo, pQueryPool); chunk = scope.Get(); } diff --git a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp index bb7db6de9..137f61988 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp @@ -25,6 +25,7 @@ #include "../vk_core.h" bool WrappedVulkan::Serialise_vkGetDeviceQueue( + Serialiser* localSerialiser, VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, @@ -82,8 +83,10 @@ VkResult WrappedVulkan::vkGetDeviceQueue( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(GET_DEVICE_QUEUE); - Serialise_vkGetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); + Serialise_vkGetDeviceQueue(localSerialiser, device, queueNodeIndex, queueIndex, pQueue); chunk = scope.Get(); } @@ -106,6 +109,7 @@ VkResult WrappedVulkan::vkGetDeviceQueue( } bool WrappedVulkan::Serialise_vkQueueSubmit( + Serialiser* localSerialiser, VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, @@ -151,7 +155,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( fence = VK_NULL_HANDLE; } - const string desc = GetSerialiser()->GetDebugStr(); + const string desc = localSerialiser->GetDebugStr(); if(m_State == READING) { @@ -369,8 +373,10 @@ VkResult WrappedVulkan::vkQueueSubmit( if(m_State == WRITING_CAPFRAME) { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(QUEUE_SUBMIT); - Serialise_vkQueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); + Serialise_vkQueueSubmit(localSerialiser, queue, cmdBufferCount, pCmdBuffers, fence); m_FrameCaptureRecord->AddChunk(scope.Get()); } @@ -416,7 +422,7 @@ VkResult WrappedVulkan::vkQueueSubmit( return ret; } -bool WrappedVulkan::Serialise_vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) +bool WrappedVulkan::Serialise_vkQueueSignalSemaphore(Serialiser* localSerialiser, VkQueue queue, VkSemaphore semaphore) { SERIALISE_ELEMENT(ResourceId, qid, GetResID(queue)); SERIALISE_ELEMENT(ResourceId, sid, GetResID(semaphore)); @@ -436,8 +442,10 @@ VkResult WrappedVulkan::vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaph if(m_State >= WRITING) { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(QUEUE_SIGNAL_SEMAPHORE); - Serialise_vkQueueSignalSemaphore(queue, semaphore); + Serialise_vkQueueSignalSemaphore(localSerialiser, queue, semaphore); m_FrameCaptureRecord->AddChunk(scope.Get()); GetResourceManager()->MarkResourceFrameReferenced(GetResID(queue), eFrameRef_Read); @@ -447,7 +455,7 @@ VkResult WrappedVulkan::vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaph return ret; } -bool WrappedVulkan::Serialise_vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) +bool WrappedVulkan::Serialise_vkQueueWaitSemaphore(Serialiser* localSerialiser, VkQueue queue, VkSemaphore semaphore) { SERIALISE_ELEMENT(ResourceId, qid, GetResID(queue)); SERIALISE_ELEMENT(ResourceId, sid, GetResID(semaphore)); @@ -467,8 +475,10 @@ VkResult WrappedVulkan::vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphor if(m_State >= WRITING_CAPFRAME) { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(QUEUE_WAIT_SEMAPHORE); - Serialise_vkQueueWaitSemaphore(queue, semaphore); + Serialise_vkQueueWaitSemaphore(localSerialiser, queue, semaphore); m_FrameCaptureRecord->AddChunk(scope.Get()); GetResourceManager()->MarkResourceFrameReferenced(GetResID(queue), eFrameRef_Read); @@ -478,7 +488,7 @@ VkResult WrappedVulkan::vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphor return ret; } -bool WrappedVulkan::Serialise_vkQueueWaitIdle(VkQueue queue) +bool WrappedVulkan::Serialise_vkQueueWaitIdle(Serialiser* localSerialiser, VkQueue queue) { SERIALISE_ELEMENT(ResourceId, id, GetResID(queue)); @@ -497,8 +507,10 @@ VkResult WrappedVulkan::vkQueueWaitIdle(VkQueue queue) if(m_State >= WRITING_CAPFRAME) { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(QUEUE_WAIT_IDLE); - Serialise_vkQueueWaitIdle(queue); + Serialise_vkQueueWaitIdle(localSerialiser, queue); m_FrameCaptureRecord->AddChunk(scope.Get()); GetResourceManager()->MarkResourceFrameReferenced(GetResID(queue), eFrameRef_Read); diff --git a/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp index b94c42838..0b4e7f45d 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_resource_funcs.cpp @@ -27,6 +27,7 @@ // Memory functions bool WrappedVulkan::Serialise_vkAllocMemory( + Serialiser* localSerialiser, VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) @@ -77,8 +78,10 @@ VkResult WrappedVulkan::vkAllocMemory( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(ALLOC_MEM); - Serialise_vkAllocMemory(device, pAllocInfo, pMem); + Serialise_vkAllocMemory(localSerialiser, device, pAllocInfo, pMem); chunk = scope.Get(); } @@ -164,6 +167,7 @@ VkResult WrappedVulkan::vkMapMemory( } bool WrappedVulkan::Serialise_vkUnmapMemory( + Serialiser* localSerialiser, VkDevice device, VkDeviceMemory mem) { @@ -238,8 +242,10 @@ VkResult WrappedVulkan::vkUnmapMemory( { if(!it->second.mapFlushed) { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(UNMAP_MEM); - Serialise_vkUnmapMemory(device, mem); + Serialise_vkUnmapMemory(localSerialiser, device, mem); VkResourceRecord *record = GetRecord(mem); @@ -274,6 +280,7 @@ VkResult WrappedVulkan::vkUnmapMemory( } bool WrappedVulkan::Serialise_vkFlushMappedMemoryRanges( + Serialiser* localSerialiser, VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) @@ -349,8 +356,10 @@ VkResult WrappedVulkan::vkFlushMappedMemoryRanges( if(ret == VK_SUCCESS && m_State >= WRITING_CAPFRAME) { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(FLUSH_MEM); - Serialise_vkFlushMappedMemoryRanges(device, 1, pMemRanges+i); + Serialise_vkFlushMappedMemoryRanges(localSerialiser, device, 1, pMemRanges+i); m_FrameCaptureRecord->AddChunk(scope.Get()); GetResourceManager()->MarkResourceFrameReferenced(GetResID(pMemRanges[i].mem), eFrameRef_Write); @@ -363,6 +372,7 @@ VkResult WrappedVulkan::vkFlushMappedMemoryRanges( // Generic API object functions bool WrappedVulkan::Serialise_vkBindBufferMemory( + Serialiser* localSerialiser, VkDevice device, VkBuffer buffer, VkDeviceMemory mem, @@ -400,8 +410,10 @@ VkResult WrappedVulkan::vkBindBufferMemory( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BIND_BUFFER_MEM); - Serialise_vkBindBufferMemory(device, buffer, mem, memOffset); + Serialise_vkBindBufferMemory(localSerialiser, device, buffer, mem, memOffset); chunk = scope.Get(); } @@ -425,6 +437,7 @@ VkResult WrappedVulkan::vkBindBufferMemory( } bool WrappedVulkan::Serialise_vkBindImageMemory( + Serialiser* localSerialiser, VkDevice device, VkImage image, VkDeviceMemory mem, @@ -460,8 +473,10 @@ VkResult WrappedVulkan::vkBindImageMemory( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(BIND_IMAGE_MEM); - Serialise_vkBindImageMemory(device, image, mem, memOffset); + Serialise_vkBindImageMemory(localSerialiser, device, image, mem, memOffset); chunk = scope.Get(); } @@ -485,6 +500,7 @@ VkResult WrappedVulkan::vkBindImageMemory( } bool WrappedVulkan::Serialise_vkCreateBuffer( + Serialiser* localSerialiser, VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) @@ -534,8 +550,10 @@ VkResult WrappedVulkan::vkCreateBuffer( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_BUFFER); - Serialise_vkCreateBuffer(device, pCreateInfo, pBuffer); + Serialise_vkCreateBuffer(localSerialiser, device, pCreateInfo, pBuffer); chunk = scope.Get(); } @@ -553,6 +571,7 @@ VkResult WrappedVulkan::vkCreateBuffer( } bool WrappedVulkan::Serialise_vkCreateBufferView( + Serialiser* localSerialiser, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) @@ -603,8 +622,10 @@ VkResult WrappedVulkan::vkCreateBufferView( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_BUFFER_VIEW); - Serialise_vkCreateBufferView(device, pCreateInfo, pView); + Serialise_vkCreateBufferView(localSerialiser, device, pCreateInfo, pView); chunk = scope.Get(); } @@ -623,6 +644,7 @@ VkResult WrappedVulkan::vkCreateBufferView( } bool WrappedVulkan::Serialise_vkCreateImage( + Serialiser* localSerialiser, VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) @@ -693,8 +715,10 @@ VkResult WrappedVulkan::vkCreateImage( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_IMAGE); - Serialise_vkCreateImage(device, pCreateInfo, pImage); + Serialise_vkCreateImage(localSerialiser, device, pCreateInfo, pImage); chunk = scope.Get(); } @@ -739,6 +763,7 @@ VkResult WrappedVulkan::vkCreateImage( // Image view functions bool WrappedVulkan::Serialise_vkCreateImageView( + Serialiser* localSerialiser, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) @@ -789,8 +814,10 @@ VkResult WrappedVulkan::vkCreateImageView( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_IMAGE_VIEW); - Serialise_vkCreateImageView(device, pCreateInfo, pView); + Serialise_vkCreateImageView(localSerialiser, device, pCreateInfo, pView); chunk = scope.Get(); } @@ -809,6 +836,7 @@ VkResult WrappedVulkan::vkCreateImageView( } bool WrappedVulkan::Serialise_vkCreateAttachmentView( + Serialiser* localSerialiser, VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView) @@ -859,8 +887,10 @@ VkResult WrappedVulkan::vkCreateAttachmentView( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_ATTACHMENT_VIEW); - Serialise_vkCreateAttachmentView(device, pCreateInfo, pView); + Serialise_vkCreateAttachmentView(localSerialiser, device, pCreateInfo, pView); chunk = scope.Get(); } diff --git a/renderdoc/driver/vulkan/wrappers/vk_shader_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_shader_funcs.cpp index 2470d19c4..ac8ba8917 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_shader_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_shader_funcs.cpp @@ -28,6 +28,7 @@ // Shader functions bool WrappedVulkan::Serialise_vkCreatePipelineLayout( + Serialiser* localSerialiser, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) @@ -85,8 +86,10 @@ VkResult WrappedVulkan::vkCreatePipelineLayout( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_PIPE_LAYOUT); - Serialise_vkCreatePipelineLayout(device, pCreateInfo, pPipelineLayout); + Serialise_vkCreatePipelineLayout(localSerialiser, device, pCreateInfo, pPipelineLayout); chunk = scope.Get(); } @@ -110,6 +113,7 @@ VkResult WrappedVulkan::vkCreatePipelineLayout( } bool WrappedVulkan::Serialise_vkCreateShaderModule( + Serialiser* localSerialiser, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) @@ -160,8 +164,10 @@ VkResult WrappedVulkan::vkCreateShaderModule( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_SHADER_MODULE); - Serialise_vkCreateShaderModule(device, pCreateInfo, pShaderModule); + Serialise_vkCreateShaderModule(localSerialiser, device, pCreateInfo, pShaderModule); chunk = scope.Get(); } @@ -179,6 +185,7 @@ VkResult WrappedVulkan::vkCreateShaderModule( } bool WrappedVulkan::Serialise_vkCreateShader( + Serialiser* localSerialiser, VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) @@ -233,8 +240,10 @@ VkResult WrappedVulkan::vkCreateShader( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_SHADER); - Serialise_vkCreateShader(device, pCreateInfo, pShader); + Serialise_vkCreateShader(localSerialiser, device, pCreateInfo, pShader); chunk = scope.Get(); } @@ -257,6 +266,7 @@ VkResult WrappedVulkan::vkCreateShader( // Pipeline functions bool WrappedVulkan::Serialise_vkCreatePipelineCache( + Serialiser* localSerialiser, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) @@ -302,8 +312,10 @@ VkResult WrappedVulkan::vkCreatePipelineCache( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_PIPE_CACHE); - Serialise_vkCreatePipelineCache(device, pCreateInfo, pPipelineCache); + Serialise_vkCreatePipelineCache(localSerialiser, device, pCreateInfo, pPipelineCache); chunk = scope.Get(); } @@ -321,6 +333,7 @@ VkResult WrappedVulkan::vkCreatePipelineCache( } bool WrappedVulkan::Serialise_vkCreateGraphicsPipelines( + Serialiser* localSerialiser, VkDevice device, VkPipelineCache pipelineCache, uint32_t count, @@ -401,8 +414,10 @@ VkResult WrappedVulkan::vkCreateGraphicsPipelines( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_GRAPHICS_PIPE); - Serialise_vkCreateGraphicsPipelines(device, pipelineCache, 1, &pCreateInfos[i], &pPipelines[i]); + Serialise_vkCreateGraphicsPipelines(localSerialiser, device, pipelineCache, 1, &pCreateInfos[i], &pPipelines[i]); chunk = scope.Get(); } diff --git a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp index f00e2a8e8..134277518 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_wsi_funcs.cpp @@ -60,6 +60,7 @@ VkResult WrappedVulkan::vkGetSurfaceInfoWSI( } bool WrappedVulkan::Serialise_vkGetSwapChainInfoWSI( + Serialiser* localSerialiser, VkDevice device, VkSwapChainWSI swapChain, VkSwapChainInfoTypeWSI infoType, @@ -123,8 +124,10 @@ VkResult WrappedVulkan::vkGetSwapChainInfoWSI( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(PRESENT_IMAGE); - Serialise_vkGetSwapChainInfoWSI(device, swapChain, infoType, &i, (void *)&images[i]); + Serialise_vkGetSwapChainInfoWSI(localSerialiser, device, swapChain, infoType, &i, (void *)&images[i]); chunk = scope.Get(); } @@ -165,6 +168,7 @@ VkResult WrappedVulkan::vkAcquireNextImageWSI( } bool WrappedVulkan::Serialise_vkCreateSwapChainWSI( + Serialiser* localSerialiser, VkDevice device, const VkSwapChainCreateInfoWSI* pCreateInfo, VkSwapChainWSI* pSwapChain) @@ -310,8 +314,10 @@ VkResult WrappedVulkan::vkCreateSwapChainWSI( Chunk *chunk = NULL; { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CREATE_SWAP_BUFFER); - Serialise_vkCreateSwapChainWSI(device, pCreateInfo, pSwapChain); + Serialise_vkCreateSwapChainWSI(localSerialiser, device, pCreateInfo, pSwapChain); chunk = scope.Get(); } @@ -883,6 +889,8 @@ VkResult WrappedVulkan::vkQueuePresentWSI( Serialiser *m_pFileSerialiser = RenderDoc::Inst().OpenWriteSerialiser(m_FrameCounter, &m_InitParams, jpgbuf, len, thwidth, thheight); { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(DEVICE_INIT); m_pFileSerialiser->Insert(scope.Get(true)); @@ -899,6 +907,8 @@ VkResult WrappedVulkan::vkQueuePresentWSI( RDCDEBUG("Creating Capture Scope"); { + CACHE_THREAD_SERIALISER(); + SCOPED_SERIALISE_CONTEXT(CAPTURE_SCOPE); Serialise_CaptureScope(0); diff --git a/renderdoc/serialise/serialiser.h b/renderdoc/serialise/serialiser.h index 25320256a..b99e199f3 100644 --- a/renderdoc/serialise/serialiser.h +++ b/renderdoc/serialise/serialiser.h @@ -756,17 +756,20 @@ class ScopedContext } }; -#define SCOPED_SERIALISE_CONTEXT(n) ScopedContext scope(GetSerialiser(), GetChunkName(n), n, false); -#define SCOPED_SERIALISE_SMALL_CONTEXT(n) ScopedContext scope(GetSerialiser(), GetChunkName(n), n, true); +// can be overridden to locally cache the serialiser pointer (e.g. for TLS lookup) +#define GET_SERIALISER GetSerialiser() -#define SERIALISE_ELEMENT(type, name, inValue) type name; if(m_State >= WRITING) name = (inValue); GetSerialiser()->Serialise(#name, name); -#define SERIALISE_ELEMENT_OPT(type, name, inValue, Condition) type name = type(); if(Condition) { if(m_State >= WRITING) name = (inValue); GetSerialiser()->Serialise(#name, name); } -#define SERIALISE_ELEMENT_ARR(type, name, inValues, count) type *name = new type[count]; for(size_t serialiseIdx=0; serialiseIdx < count; serialiseIdx++) { if(m_State >= WRITING) name[serialiseIdx] = (inValues)[serialiseIdx]; GetSerialiser()->Serialise(#name, name[serialiseIdx]); } -#define SERIALISE_ELEMENT_ARR_OPT(type, name, inValues, count, Condition) type *name = NULL; if(Condition) { name = new type[count]; for(size_t serialiseIdx=0; serialiseIdx < count; serialiseIdx++) { if(m_State >= WRITING) name[serialiseIdx] = (inValues)[serialiseIdx]; GetSerialiser()->Serialise(#name, name[serialiseIdx]); } } -#define SERIALISE_ELEMENT_PTR(type, name, inValue) type name; if(inValue && m_State >= WRITING) name = *(inValue); GetSerialiser()->Serialise(#name, name); -#define SERIALISE_ELEMENT_PTR_OPT(type, name, inValue, Condition) type name; if(Condition) { if(inValue && m_State >= WRITING) name = *(inValue); GetSerialiser()->Serialise(#name, name); } -#define SERIALISE_ELEMENT_BUF(type, name, inBuf, Len) type name = (type)NULL; if(m_State >= WRITING) name = (type)(inBuf); size_t CONCAT(buflen, __LINE__) = Len; GetSerialiser()->SerialiseBuffer(#name, name, CONCAT(buflen, __LINE__)); -#define SERIALISE_ELEMENT_BUF_OPT(type, name, inBuf, Len, Condition) type name = (type)NULL; if(Condition) { if(m_State >= WRITING) name = (type)(inBuf); size_t CONCAT(buflen, __LINE__) = Len; GetSerialiser()->SerialiseBuffer(#name, name, CONCAT(buflen, __LINE__)); } +#define SCOPED_SERIALISE_CONTEXT(n) ScopedContext scope(GET_SERIALISER, GetChunkName(n), n, false); +#define SCOPED_SERIALISE_SMALL_CONTEXT(n) ScopedContext scope(GET_SERIALISER, GetChunkName(n), n, true); + +#define SERIALISE_ELEMENT(type, name, inValue) type name; if(m_State >= WRITING) name = (inValue); GET_SERIALISER->Serialise(#name, name); +#define SERIALISE_ELEMENT_OPT(type, name, inValue, Condition) type name = type(); if(Condition) { if(m_State >= WRITING) name = (inValue); GET_SERIALISER->Serialise(#name, name); } +#define SERIALISE_ELEMENT_ARR(type, name, inValues, count) type *name = new type[count]; for(size_t serialiseIdx=0; serialiseIdx < count; serialiseIdx++) { if(m_State >= WRITING) name[serialiseIdx] = (inValues)[serialiseIdx]; GET_SERIALISER->Serialise(#name, name[serialiseIdx]); } +#define SERIALISE_ELEMENT_ARR_OPT(type, name, inValues, count, Condition) type *name = NULL; if(Condition) { name = new type[count]; for(size_t serialiseIdx=0; serialiseIdx < count; serialiseIdx++) { if(m_State >= WRITING) name[serialiseIdx] = (inValues)[serialiseIdx]; GET_SERIALISER->Serialise(#name, name[serialiseIdx]); } } +#define SERIALISE_ELEMENT_PTR(type, name, inValue) type name; if(inValue && m_State >= WRITING) name = *(inValue); GET_SERIALISER->Serialise(#name, name); +#define SERIALISE_ELEMENT_PTR_OPT(type, name, inValue, Condition) type name; if(Condition) { if(inValue && m_State >= WRITING) name = *(inValue); GET_SERIALISER->Serialise(#name, name); } +#define SERIALISE_ELEMENT_BUF(type, name, inBuf, Len) type name = (type)NULL; if(m_State >= WRITING) name = (type)(inBuf); size_t CONCAT(buflen, __LINE__) = Len; GET_SERIALISER->SerialiseBuffer(#name, name, CONCAT(buflen, __LINE__)); +#define SERIALISE_ELEMENT_BUF_OPT(type, name, inBuf, Len, Condition) type name = (type)NULL; if(Condition) { if(m_State >= WRITING) name = (type)(inBuf); size_t CONCAT(buflen, __LINE__) = Len; GET_SERIALISER->SerialiseBuffer(#name, name, CONCAT(buflen, __LINE__)); } // forward declare generic pointer version to void* template