lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-09-11 08:15:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add fence functions and a FlushMappedMemory that just prints for now

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