Skip to content

Commit 20df1e1

Browse files
tuxerrtuxerr
committed
keep driver's pipelineCacheUUID valid and use it for replay
1 parent e4b4cb0 commit 20df1e1

File tree

2 files changed

+41
-131
lines changed

2 files changed

+41
-131
lines changed

‎renderdoc/driver/vulkan/wrappers/vk_get_funcs.cpp

+12-80
Original file line numberDiff line numberDiff line change
@@ -26,24 +26,6 @@
2626
#include "../vk_debug.h"
2727
#include "api/replay/version.h"
2828

29-
static char fakeRenderDocUUID[VK_UUID_SIZE] = {};
30-
31-
void MakeFakeUUID()
32-
{
33-
// assign a fake UUID, so that we get SPIR-V instead of cached pipeline data.
34-
// the start is "rdoc", and the end is the time that this call was first made
35-
if(fakeRenderDocUUID[0] == 0)
36-
{
37-
// 0123456789ABCDEF
38-
// rdocyymmddHHMMSS
39-
// we pass size+1 so that there's room for a null terminator (the UUID doesn't
40-
// need a null terminator as it's a fixed size non-string array)
41-
rdcstr uuid = StringFormat::sntimef(Timing::GetUTCTime(), "rdoc%y%m%d%H%M%S");
42-
RDCASSERT(uuid.size() == sizeof(fakeRenderDocUUID));
43-
memcpy(fakeRenderDocUUID, uuid.c_str(), RDCMIN((size_t)VK_UUID_SIZE, uuid.size()));
44-
}
45-
}
46-
4729
void ClampPhysDevAPIVersion(VkPhysicalDeviceProperties *pProperties, VkPhysicalDevice physicalDevice)
4830
{
4931
// for Vulkan 1.3 bufferDeviceAddress is core. If the bufferDeviceAddressCaptureReplay feature is
@@ -234,10 +216,6 @@ void WrappedVulkan::vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevic
234216
{
235217
ObjDisp(physicalDevice)->GetPhysicalDeviceProperties(Unwrap(physicalDevice), pProperties);
236218

237-
MakeFakeUUID();
238-
239-
memcpy(pProperties->pipelineCacheUUID, fakeRenderDocUUID, VK_UUID_SIZE);
240-
241219
ClampPhysDevAPIVersion(pProperties, physicalDevice);
242220
}
243221

@@ -639,57 +617,25 @@ void WrappedVulkan::vkGetRenderAreaGranularity(VkDevice device, VkRenderPass ren
639617
VkResult WrappedVulkan::vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
640618
size_t *pDataSize, void *pData)
641619
{
642-
// required header and 4 NULL bytes
643-
size_t totalSize = sizeof(VkPipelineCacheHeaderVersionOne) + 4;
644-
645-
if(pDataSize && !pData)
646-
*pDataSize = totalSize;
647-
648-
if(pDataSize && pData)
649-
{
650-
if(*pDataSize < totalSize)
651-
{
652-
memset(pData, 0, *pDataSize);
653-
return VK_INCOMPLETE;
654-
}
655-
656-
VkPipelineCacheHeaderVersionOne *header = (VkPipelineCacheHeaderVersionOne *)pData;
657-
658-
RDCCOMPILE_ASSERT(sizeof(VkPipelineCacheHeaderVersionOne) == 16 + VK_UUID_SIZE,
659-
"Pipeline cache header size is wrong");
660-
661-
header->headerSize = sizeof(VkPipelineCacheHeaderVersionOne);
662-
header->headerVersion = VK_PIPELINE_CACHE_HEADER_VERSION_ONE;
663-
// just in case the user expects a valid vendorID/deviceID, write the real one
664-
// MULTIDEVICE need to get the right physical device for this device
665-
header->vendorID = m_PhysicalDeviceData.props.vendorID;
666-
header->deviceID = m_PhysicalDeviceData.props.deviceID;
667-
668-
MakeFakeUUID();
669-
670-
memcpy(header->pipelineCacheUUID, fakeRenderDocUUID, VK_UUID_SIZE);
671-
672-
RDCCOMPILE_ASSERT(VK_UUID_SIZE == 16, "VK_UUID_SIZE has changed");
673-
674-
// empty bytes
675-
uint32_t *ptr = (uint32_t *)(header + 1);
676-
*ptr = 0;
677-
}
678-
679-
// we don't want the application to use pipeline caches at all, and especially
680-
// don't want to return any data for future use. We thus return a technically
681-
// valid but empty pipeline cache. Our UUID changes every run so in theory the
682-
// application should never provide an old cache, but just in case we will nop
683-
// it out in create pipeline cache
684-
return VK_SUCCESS;
620+
return ObjDisp(device)->GetPipelineCacheData(Unwrap(device), Unwrap(pipelineCache), pDataSize,
621+
pData);
685622
}
686623

687624
VkResult WrappedVulkan::vkMergePipelineCaches(VkDevice device, VkPipelineCache destCache,
688625
uint32_t srcCacheCount,
689626
const VkPipelineCache *pSrcCaches)
690627
{
691628
// do nothing, our pipeline caches are always dummies
692-
return VK_SUCCESS;
629+
rdcarray<VkPipelineCache> unwrappedPipelineCaches;
630+
631+
unwrappedPipelineCaches.reserve(srcCacheCount);
632+
for(uint32_t cacheIndex = 0; cacheIndex < srcCacheCount; cacheIndex++)
633+
{
634+
unwrappedPipelineCaches.push_back(Unwrap(pSrcCaches[cacheIndex]));
635+
}
636+
637+
return ObjDisp(device)->MergePipelineCaches(Unwrap(device), Unwrap(destCache), srcCacheCount,
638+
unwrappedPipelineCaches.data());
693639
}
694640

695641
VkResult WrappedVulkan::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
@@ -893,21 +839,7 @@ void WrappedVulkan::vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevi
893839
{
894840
ObjDisp(physicalDevice)->GetPhysicalDeviceProperties2(Unwrap(physicalDevice), pProperties);
895841

896-
MakeFakeUUID();
897-
898-
memcpy(pProperties->properties.pipelineCacheUUID, fakeRenderDocUUID, VK_UUID_SIZE);
899-
900842
ClampPhysDevAPIVersion(&pProperties->properties, physicalDevice);
901-
902-
// internal RenderDoc UUID for shader object binary
903-
VkPhysicalDeviceShaderObjectPropertiesEXT *shadObj =
904-
(VkPhysicalDeviceShaderObjectPropertiesEXT *)FindNextStruct(
905-
pProperties, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT);
906-
907-
if(shadObj)
908-
{
909-
memcpy(shadObj->shaderBinaryUUID, fakeRenderDocUUID, VK_UUID_SIZE);
910-
}
911843
}
912844

913845
void WrappedVulkan::vkGetPhysicalDeviceQueueFamilyProperties2(

‎renderdoc/driver/vulkan/wrappers/vk_shader_funcs.cpp

+29-51
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@
2929

3030
RDOC_EXTERN_CONFIG(bool, Replay_Debug_SingleThreadedCompilation);
3131

32-
static RDResult DeferredPipelineCompile(VkDevice device,
32+
static RDResult DeferredPipelineCompile(VkDevice device, const VkPipelineCache &pipelineCache,
3333
const VkGraphicsPipelineCreateInfo &createInfo,
3434
WrappedVkPipeline *wrappedPipe)
3535
{
@@ -38,7 +38,7 @@ static RDResult DeferredPipelineCompile(VkDevice device,
3838
UnwrapStructAndChain(CaptureState::LoadingReplaying, mem, &createInfo);
3939

4040
VkPipeline realPipe;
41-
VkResult ret = ObjDisp(device)->CreateGraphicsPipelines(Unwrap(device), VK_NULL_HANDLE, 1,
41+
VkResult ret = ObjDisp(device)->CreateGraphicsPipelines(Unwrap(device), Unwrap(pipelineCache), 1,
4242
unwrapped, NULL, &realPipe);
4343

4444
FreeAlignedBuffer((byte *)unwrapped);
@@ -54,7 +54,7 @@ static RDResult DeferredPipelineCompile(VkDevice device,
5454
return ResultCode::Succeeded;
5555
}
5656

57-
static RDResult DeferredPipelineCompile(VkDevice device,
57+
static RDResult DeferredPipelineCompile(VkDevice device, const VkPipelineCache &pipelineCache,
5858
const VkComputePipelineCreateInfo &createInfo,
5959
WrappedVkPipeline *wrappedPipe)
6060
{
@@ -63,7 +63,7 @@ static RDResult DeferredPipelineCompile(VkDevice device,
6363
UnwrapStructAndChain(CaptureState::LoadingReplaying, mem, &createInfo);
6464

6565
VkPipeline realPipe;
66-
VkResult ret = ObjDisp(device)->CreateComputePipelines(Unwrap(device), VK_NULL_HANDLE, 1,
66+
VkResult ret = ObjDisp(device)->CreateComputePipelines(Unwrap(device), Unwrap(pipelineCache), 1,
6767
unwrapped, NULL, &realPipe);
6868

6969
FreeAlignedBuffer((byte *)unwrapped);
@@ -79,7 +79,7 @@ static RDResult DeferredPipelineCompile(VkDevice device,
7979
return ResultCode::Succeeded;
8080
}
8181

82-
static RDResult DeferredPipelineCompile(VkDevice device,
82+
static RDResult DeferredPipelineCompile(VkDevice device, const VkPipelineCache &pipelineCache,
8383
const VkRayTracingPipelineCreateInfoKHR &createInfo,
8484
const bytebuf &replayHandles,
8585
uint32_t captureReplayHandleSize,
@@ -98,7 +98,7 @@ static RDResult DeferredPipelineCompile(VkDevice device,
9898

9999
VkPipeline realPipe;
100100
VkResult ret = ObjDisp(device)->CreateRayTracingPipelinesKHR(
101-
Unwrap(device), VK_NULL_HANDLE, VK_NULL_HANDLE, 1, unwrapped, NULL, &realPipe);
101+
Unwrap(device), VK_NULL_HANDLE, Unwrap(pipelineCache), 1, unwrapped, NULL, &realPipe);
102102

103103
FreeAlignedBuffer((byte *)unwrapped);
104104

@@ -660,18 +660,7 @@ VkResult WrappedVulkan::vkCreatePipelineCache(VkDevice device,
660660
const VkAllocationCallbacks *,
661661
VkPipelineCache *pPipelineCache)
662662
{
663-
// pretend the user didn't provide any cache data
664-
665663
VkPipelineCacheCreateInfo createInfo = *pCreateInfo;
666-
createInfo.initialDataSize = 0;
667-
createInfo.pInitialData = NULL;
668-
669-
if(pCreateInfo->initialDataSize > 0)
670-
{
671-
RDCWARN(
672-
"Application provided pipeline cache data! This is invalid, as RenderDoc reports "
673-
"incompatibility with previous caches");
674-
}
675664

676665
VkResult ret;
677666
SERIALISE_TIME_CALL(ret = ObjDisp(device)->CreatePipelineCache(Unwrap(device), &createInfo, NULL,
@@ -726,10 +715,6 @@ bool WrappedVulkan::Serialise_vkCreateGraphicsPipelines(
726715
VkPipeline pipe = VK_NULL_HANDLE;
727716

728717
VkRenderPass origRP = CreateInfo.renderPass;
729-
VkPipelineCache origCache = pipelineCache;
730-
731-
// don't use pipeline caches on replay
732-
pipelineCache = VK_NULL_HANDLE;
733718

734719
// if we have pipeline executable properties, capture the data
735720
if(GetExtensions(NULL).ext_KHR_pipeline_executable_properties)
@@ -852,8 +837,8 @@ bool WrappedVulkan::Serialise_vkCreateGraphicsPipelines(
852837
}
853838

854839
DerivedResource(device, Pipeline);
855-
if(origCache != VK_NULL_HANDLE)
856-
DerivedResource(origCache, Pipeline);
840+
if(pipelineCache != VK_NULL_HANDLE)
841+
DerivedResource(pipelineCache, Pipeline);
857842
if(OrigCreateInfo.flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
858843
{
859844
if(OrigCreateInfo.basePipelineHandle != VK_NULL_HANDLE)
@@ -887,8 +872,8 @@ bool WrappedVulkan::Serialise_vkCreateGraphicsPipelines(
887872
{
888873
for(rdcpair<VkGraphicsPipelineCreateInfo, VkPipeline> &deferredPipe : pipelinesToCompile)
889874
{
890-
RDResult res =
891-
DeferredPipelineCompile(device, deferredPipe.first, GetWrapped(deferredPipe.second));
875+
RDResult res = DeferredPipelineCompile(device, pipelineCache, deferredPipe.first,
876+
GetWrapped(deferredPipe.second));
892877

893878
if(res != ResultCode::Succeeded)
894879
{
@@ -908,10 +893,11 @@ bool WrappedVulkan::Serialise_vkCreateGraphicsPipelines(
908893
{
909894
WrappedVkPipeline *wrappedPipe = GetWrapped(deferredPipe.second);
910895
wrappedPipe->deferredJob = Threading::JobSystem::AddJob(
911-
[wrappedVulkan = this, device, createInfo = deferredPipe.first, wrappedPipe]() {
896+
[wrappedVulkan = this, device, pipelineCache, createInfo = deferredPipe.first,
897+
wrappedPipe]() {
912898
PerformanceTimer timer;
913899
wrappedVulkan->CheckDeferredResult(
914-
DeferredPipelineCompile(device, createInfo, wrappedPipe));
900+
DeferredPipelineCompile(device, pipelineCache, createInfo, wrappedPipe));
915901
wrappedVulkan->AddDeferredTime(timer.GetMilliseconds());
916902
},
917903
parents);
@@ -1074,11 +1060,6 @@ bool WrappedVulkan::Serialise_vkCreateComputePipelines(SerialiserType &ser, VkDe
10741060
{
10751061
VkPipeline pipe = VK_NULL_HANDLE;
10761062

1077-
VkPipelineCache origCache = pipelineCache;
1078-
1079-
// don't use pipeline caches on replay
1080-
pipelineCache = VK_NULL_HANDLE;
1081-
10821063
// if we have pipeline executable properties, capture the data
10831064
if(GetExtensions(NULL).ext_KHR_pipeline_executable_properties)
10841065
{
@@ -1152,7 +1133,7 @@ bool WrappedVulkan::Serialise_vkCreateComputePipelines(SerialiserType &ser, VkDe
11521133

11531134
if(Replay_Debug_SingleThreadedCompilation())
11541135
{
1155-
RDResult res = DeferredPipelineCompile(device, OrigCreateInfo, GetWrapped(pipe));
1136+
RDResult res = DeferredPipelineCompile(device, pipelineCache, OrigCreateInfo, GetWrapped(pipe));
11561137
Deserialise(OrigCreateInfo);
11571138

11581139
if(res != ResultCode::Succeeded)
@@ -1164,20 +1145,20 @@ bool WrappedVulkan::Serialise_vkCreateComputePipelines(SerialiserType &ser, VkDe
11641145
else
11651146
{
11661147
WrappedVkPipeline *wrappedPipe = GetWrapped(pipe);
1167-
wrappedPipe->deferredJob =
1168-
Threading::JobSystem::AddJob([wrappedVulkan = this, device, OrigCreateInfo, wrappedPipe]() {
1148+
wrappedPipe->deferredJob = Threading::JobSystem::AddJob(
1149+
[wrappedVulkan = this, device, pipelineCache, OrigCreateInfo, wrappedPipe]() {
11691150
PerformanceTimer timer;
11701151
wrappedVulkan->CheckDeferredResult(
1171-
DeferredPipelineCompile(device, OrigCreateInfo, wrappedPipe));
1152+
DeferredPipelineCompile(device, pipelineCache, OrigCreateInfo, wrappedPipe));
11721153
wrappedVulkan->AddDeferredTime(timer.GetMilliseconds());
11731154

11741155
Deserialise(OrigCreateInfo);
11751156
});
11761157
}
11771158

11781159
DerivedResource(device, Pipeline);
1179-
if(origCache != VK_NULL_HANDLE)
1180-
DerivedResource(origCache, Pipeline);
1160+
if(pipelineCache != VK_NULL_HANDLE)
1161+
DerivedResource(pipelineCache, Pipeline);
11811162
if(OrigCreateInfo.flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
11821163
{
11831164
if(OrigCreateInfo.basePipelineHandle != VK_NULL_HANDLE)
@@ -1360,11 +1341,6 @@ bool WrappedVulkan::Serialise_vkCreateRayTracingPipelinesKHR(
13601341

13611342
VkPipeline pipe = VK_NULL_HANDLE;
13621343

1363-
VkPipelineCache origCache = pipelineCache;
1364-
1365-
// don't use pipeline caches on replay
1366-
pipelineCache = VK_NULL_HANDLE;
1367-
13681344
// don't fail when a compile is required because we don't currently replay caches so this will
13691345
// always happen. This still allows application to use this flag at runtime where it will be
13701346
// valid
@@ -1390,8 +1366,8 @@ bool WrappedVulkan::Serialise_vkCreateRayTracingPipelinesKHR(
13901366
pipeInfo.Init(GetResourceManager(), m_CreationInfo, live, &OrigCreateInfo);
13911367

13921368
DerivedResource(device, Pipeline);
1393-
if(origCache != VK_NULL_HANDLE)
1394-
DerivedResource(origCache, Pipeline);
1369+
if(pipelineCache != VK_NULL_HANDLE)
1370+
DerivedResource(pipelineCache, Pipeline);
13951371
if(OrigCreateInfo.flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
13961372
{
13971373
if(OrigCreateInfo.basePipelineHandle != VK_NULL_HANDLE)
@@ -1418,8 +1394,9 @@ bool WrappedVulkan::Serialise_vkCreateRayTracingPipelinesKHR(
14181394

14191395
if(Replay_Debug_SingleThreadedCompilation())
14201396
{
1421-
RDResult res = DeferredPipelineCompile(device, OrigCreateInfo, *OrigReplayHandles,
1422-
captureReplayHandleSize, GetWrapped(pipe));
1397+
RDResult res =
1398+
DeferredPipelineCompile(device, pipelineCache, OrigCreateInfo, *OrigReplayHandles,
1399+
captureReplayHandleSize, GetWrapped(pipe));
14231400
if(res == ResultCode::APIHardwareUnsupported)
14241401
res.message = rdcstr(res.message) + "\n" + GetPhysDeviceCompatString(false, false);
14251402
Deserialise(OrigCreateInfo);
@@ -1435,11 +1412,12 @@ bool WrappedVulkan::Serialise_vkCreateRayTracingPipelinesKHR(
14351412
{
14361413
WrappedVkPipeline *wrappedPipe = GetWrapped(pipe);
14371414
wrappedPipe->deferredJob = Threading::JobSystem::AddJob(
1438-
[wrappedVulkan = this, device, OrigCreateInfo, OrigReplayHandles, captureReplayHandleSize,
1439-
wrappedPipe]() {
1415+
[wrappedVulkan = this, device, pipelineCache, OrigCreateInfo, OrigReplayHandles,
1416+
captureReplayHandleSize, wrappedPipe]() {
14401417
PerformanceTimer timer;
1441-
RDResult res = DeferredPipelineCompile(device, OrigCreateInfo, *OrigReplayHandles,
1442-
captureReplayHandleSize, wrappedPipe);
1418+
RDResult res =
1419+
DeferredPipelineCompile(device, pipelineCache, OrigCreateInfo, *OrigReplayHandles,
1420+
captureReplayHandleSize, wrappedPipe);
14431421
wrappedVulkan->AddDeferredTime(timer.GetMilliseconds());
14441422
if(res == ResultCode::APIHardwareUnsupported)
14451423
res.message = rdcstr(res.message) + "\n" +

0 commit comments

Comments
 (0)