Add options to save and load pipeline caches (#1276)

* Add options to save and load pipeline caches

Add three options `--save-pipeline-cache`, `--load-pipeline-cache`
and `--add-new-pipeline-caches` to manually handle pipeline cache
creation/loading instead of using the ones saved in the capture file.

This is useful when pipeline creation is slow on the target system.
You can generate the cache once then run the trace multiple times,
or generate it on a faster device type with the same GPU and driver.

When using `--save-pipeline-cache` the contents of the pipeline
caches are written to the specified file just before their
destruction, and just before the destruction of the last bound
pipeline for caches created by `--create-new-pipeline-cache`, or at
the end of the program if no destruction occurs before.

When using `--load-pipeline-cache` the contents of the pipeline
caches are loaded just before their creation, and just before the
creation of the pipeline for caches created by
`--create-new-pipeline-cache`.

If set, allows gfxreconstruct to create new vkPipelineCache objects
when it encounters a pipeline created without cache. This option
can be used in coordination with `--save-pipeline-cache` and
`--load-pipeline-cache`.

Change-Id: I40667416efe4c88033c386f6ec5fd53a86dd58ca

* Warn when using both async pipeline-creation and pipeline-cache features

* Consolidate duplicated OverrideDestroyPipeline-flavors into one

* work review comments

* Respect options_.omit_pipeline_cache_data and do not load any pipeline-data if set.

---------

Co-authored-by: Fabian Schmidt <[email protected]>

Author: marius-pelegrin-arm

USAGE_android.md

@@ -925,6 +925,23 @@ optional arguments:
               Print all block information.
   --pbis <index1,index2>
               Print block information between block index1 and block index2.
+  --save-pipeline-cache DEVICE_FILE
+                        If set, produces pipeline caches at replay time instead
+                        of using the one saved at capture time and save those
+                        caches in DEVICE_FILE.
+                        (forwarded to replay tool)
+  --load-pipeline-cache DEVICE_FILE
+                        If set, loads data created by the
+                        `--save-pipeline-cache` option in DEVICE_FILE
+                        and uses it to create the pipelines instead of the
+                        pipeline caches saved at capture time.
+                        (forwarded to replay tool)
+  --add-new-pipeline-caches
+                        If set, allows gfxreconstruct to create new
+                        vkPipelineCache objects when it encounters a pipeline
+                        created without cache. This option can be used in
+                        coordination with `--save-pipeline-cache` and
+                        `--load-pipeline-cache`. (forwarded to replay tool)
 ```
 
 The command will force-stop an active replay process before starting the replay

USAGE_desktop_Vulkan.md

@@ -800,6 +800,18 @@ Optional arguments:
               Specify the number of asynchronous pipeline-creation jobs as integer.
               If <num_jobs> is negative it will be added to the number of cpu-cores, e.g. -1 -> num_cores - 1.
               Default: 0 (do not use asynchronous operations)
+  --save-pipeline-cache <cache-file>
+                        If set, produces pipeline caches at replay time instead of using
+                        the one saved at capture time and save those caches in <cache-file>.
+  --load-pipeline-cache <cache-file>
+                        If set, loads data created by the `--save-pipeline-cache`
+                        option in <cache-file> and uses it to create the pipelines instead
+                        of the pipeline caches saved at capture time.
+  --add-new-pipeline-caches
+                        If set, allows gfxreconstruct to create new vkPipelineCache objects
+                        when it encounters a pipeline created without cache. This option can
+                        be used in coordination with `--save-pipeline-cache` and
+                        `--load-pipeline-cache`.
 
 ```
 

android/scripts/gfxrecon.py

@@ -116,6 +116,9 @@ def CreateReplayParser():
     parser.add_argument('--pbi-all', action='store_true', default=False, help='Print all block information.')
     parser.add_argument('--pbis', metavar='RANGES', default=False, help='Print block information between block index1 and block index2')
     parser.add_argument('--pcj', '--pipeline-creation-jobs', action='store_true', default=False, help='Specify the number of pipeline-creation-jobs or background-threads.')
+    parser.add_argument('--save-pipeline-cache', metavar='DEVICE_FILE', help='If set, produces pipeline caches at replay time instead of using the one saved at capture time and save those caches in DEVICE_FILE. (forwarded to replay tool)')
+    parser.add_argument('--load-pipeline-cache', metavar='DEVICE_FILE', help='If set, loads data created by the `--save-pipeline-cache` option in DEVICE_FILE and uses it to create the pipelines instead of the pipeline caches saved at capture time. (forwarded to replay tool)')
+    parser.add_argument('--add-new-pipeline-caches', action='store_true', default=False, help='If set, allows gfxreconstruct to create new vkPipelineCache objects when it encounters a pipeline created without cache. This option can be used in coordination with `--save-pipeline-cache` and `--load-pipeline-cache`. (forwarded to replay tool)')
     return parser
 
 def MakeExtrasString(args):
@@ -290,6 +293,17 @@ def MakeExtrasString(args):
         arg_list.append('--pcj')
         arg_list.append('{}'.format(args.pcj))
 
+    if args.save_pipeline_cache:
+        arg_list.append('--save-pipeline-cache')
+        arg_list.append('{}'.format(args.save_pipeline_cache))
+
+    if args.load_pipeline_cache:
+        arg_list.append('--load-pipeline-cache')
+        arg_list.append('{}'.format(args.load_pipeline_cache))
+
+    if args.add_new_pipeline_caches:
+        arg_list.append('--add-new-pipeline-caches')
+
     if args.file:
         arg_list.append(args.file)
     elif not args.version:

framework/decode/vulkan_replay_consumer_base.cpp

@@ -951,6 +951,11 @@ class VulkanReplayConsumerBase : public VulkanConsumer
                                          const StructPointerDecoder<Decoded_VkAllocationCallbacks>*     pAllocator,
                                          HandlePointerDecoder<VkPipelineCache>*                         pPipelineCache);
 
+    void OverrideDestroyPipelineCache(PFN_vkDestroyPipelineCache                                 func,
+                                      const VulkanDeviceInfo*                                    device_info,
+                                      const VulkanPipelineCacheInfo*                             pipeline_cache_info,
+                                      const StructPointerDecoder<Decoded_VkAllocationCallbacks>* pAllocator);
+
     VkResult OverrideResetDescriptorPool(PFN_vkResetDescriptorPool  func,
                                          VkResult                   original_result,
                                          const VulkanDeviceInfo*    device_info,
@@ -1205,6 +1210,16 @@ class VulkanReplayConsumerBase : public VulkanConsumer
         const VulkanDeviceInfo*                                                          device_info,
         const StructPointerDecoder<Decoded_VkAccelerationStructureDeviceAddressInfoKHR>* pInfo);
 
+    VkResult OverrideCreateRayTracingPipelinesNV(
+        PFN_vkCreateRayTracingPipelinesNV                                     func,
+        VkResult                                                              original_result,
+        const VulkanDeviceInfo*                                               device_info,
+        const VulkanPipelineCacheInfo*                                        pipeline_cache_info,
+        uint32_t                                                              createInfoCount,
+        const StructPointerDecoder<Decoded_VkRayTracingPipelineCreateInfoNV>* pCreateInfos,
+        const StructPointerDecoder<Decoded_VkAllocationCallbacks>*            pAllocator,
+        HandlePointerDecoder<VkPipeline>*                                     pPipelines);
+
     VkResult OverrideGetRayTracingShaderGroupHandlesKHR(PFN_vkGetRayTracingShaderGroupHandlesKHR func,
                                                         VkResult                                 original_result,
                                                         const VulkanDeviceInfo*                  device_info,
@@ -1361,7 +1376,7 @@ class VulkanReplayConsumerBase : public VulkanConsumer
 
     void OverrideDestroyPipeline(PFN_vkDestroyPipeline                                      func,
                                  const VulkanDeviceInfo*                                    device_info,
-                                 VulkanPipelineInfo*                                        pipeline_info,
+                                 const VulkanPipelineInfo*                                  pipeline_info,
                                  const StructPointerDecoder<Decoded_VkAllocationCallbacks>* pAllocator);
 
     void OverrideDestroyRenderPass(PFN_vkDestroyRenderPass                                    func,
@@ -1547,6 +1562,15 @@ class VulkanReplayConsumerBase : public VulkanConsumer
                                                                       VkShaderCreateInfoEXT*  create_infos,
                                                                       const format::HandleId* shaders) const;
 
+    void LoadPipelineCache(format::HandleId id, std::vector<char>& pipelineCacheData);
+    void SavePipelineCache(format::HandleId id, const VulkanDeviceInfo* device_info, VkPipelineCache pipelineCache);
+    VkPipelineCache CreateNewPipelineCache(const VulkanDeviceInfo* device_info, format::HandleId id);
+    void            TrackNewPipelineCache(const VulkanDeviceInfo* device_info,
+                                          format::HandleId        id,
+                                          VkPipelineCache         pipelineCache,
+                                          VkPipeline*             pipelines,
+                                          uint32_t                pipelineCount);
+
   private:
     struct HardwareBufferInfo
     {
@@ -1659,6 +1683,9 @@ class VulkanReplayConsumerBase : public VulkanConsumer
     void*                capture_pipeline_cache_data_;
     bool                 matched_replay_cache_data_exist_ = false;
     std::vector<uint8_t> matched_replay_cache_data_;
+
+    std::unordered_map<format::HandleId, std::pair<const VulkanDeviceInfo*, VkPipelineCache>> tracked_pipeline_caches_;
+    std::unordered_map<VkPipeline, format::HandleId> pipeline_cache_correspondances_;
 };
 
 GFXRECON_END_NAMESPACE(decode)

framework/decode/vulkan_replay_consumer_base.h

@@ -96,6 +96,10 @@ struct VulkanReplayOptions : public ReplayOptions
     bool  dump_resources_dump_separate_alpha{ false };
 
     bool preload_measurement_range{ false };
+
+    std::string load_pipeline_cache_filename;
+    std::string save_pipeline_cache_filename;
+    bool        add_new_pipeline_caches;
 };
 
 GFXRECON_END_NAMESPACE(decode)

framework/decode/vulkan_replay_options.h

@@ -923,11 +923,10 @@ void VulkanReplayConsumer::Process_vkDestroyPipelineCache(
     format::HandleId                            pipelineCache,
     StructPointerDecoder<Decoded_VkAllocationCallbacks>* pAllocator)
 {
-    VkDevice in_device = MapHandle<VulkanDeviceInfo>(device, &CommonObjectInfoTable::GetVkDeviceInfo);
-    VkPipelineCache in_pipelineCache = MapHandle<VulkanPipelineCacheInfo>(pipelineCache, &CommonObjectInfoTable::GetVkPipelineCacheInfo);
-    const VkAllocationCallbacks* in_pAllocator = GetAllocationCallbacks(pAllocator);
+    auto in_device = GetObjectInfoTable().GetVkDeviceInfo(device);
+    auto in_pipelineCache = GetObjectInfoTable().GetVkPipelineCacheInfo(pipelineCache);
 
-    GetDeviceTable(in_device)->DestroyPipelineCache(in_device, in_pipelineCache, in_pAllocator);
+    OverrideDestroyPipelineCache(GetDeviceTable(in_device->handle)->DestroyPipelineCache, in_device, in_pipelineCache, pAllocator);
     RemoveHandle(pipelineCache, &CommonObjectInfoTable::RemoveVkPipelineCacheInfo);
 }
 
@@ -7549,19 +7548,19 @@ void VulkanReplayConsumer::Process_vkCreateRayTracingPipelinesNV(
     StructPointerDecoder<Decoded_VkAllocationCallbacks>* pAllocator,
     HandlePointerDecoder<VkPipeline>*           pPipelines)
 {
-    VkDevice in_device = MapHandle<VulkanDeviceInfo>(device, &CommonObjectInfoTable::GetVkDeviceInfo);
-    VkPipelineCache in_pipelineCache = MapHandle<VulkanPipelineCacheInfo>(pipelineCache, &CommonObjectInfoTable::GetVkPipelineCacheInfo);
-    const VkRayTracingPipelineCreateInfoNV* in_pCreateInfos = pCreateInfos->GetPointer();
+    auto in_device = GetObjectInfoTable().GetVkDeviceInfo(device);
+    auto in_pipelineCache = GetObjectInfoTable().GetVkPipelineCacheInfo(pipelineCache);
+
     MapStructArrayHandles(pCreateInfos->GetMetaStructPointer(), pCreateInfos->GetLength(), GetObjectInfoTable());
-    const VkAllocationCallbacks* in_pAllocator = GetAllocationCallbacks(pAllocator);
     if (!pPipelines->IsNull()) { pPipelines->SetHandleLength(createInfoCount); }
     if (omitted_pipeline_cache_data_) {AllowCompileDuringPipelineCreation(createInfoCount, pCreateInfos->GetPointer());}
-    VkPipeline* out_pPipelines = pPipelines->GetHandlePointer();
+    std::vector<VulkanPipelineInfo> handle_info(createInfoCount);
+    for (size_t i = 0; i < createInfoCount; ++i) { pPipelines->SetConsumerData(i, &handle_info[i]); }
 
-    VkResult replay_result = GetDeviceTable(in_device)->CreateRayTracingPipelinesNV(in_device, in_pipelineCache, createInfoCount, in_pCreateInfos, in_pAllocator, out_pPipelines);
+    VkResult replay_result = OverrideCreateRayTracingPipelinesNV(GetDeviceTable(in_device->handle)->CreateRayTracingPipelinesNV, returnValue, in_device, in_pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
     CheckResult("vkCreateRayTracingPipelinesNV", returnValue, replay_result, call_info);
 
-    AddHandles<VulkanPipelineInfo>(device, pPipelines->GetPointer(), pPipelines->GetLength(), out_pPipelines, createInfoCount, &CommonObjectInfoTable::AddVkPipelineInfo);
+    AddHandles<VulkanPipelineInfo>(device, pPipelines->GetPointer(), pPipelines->GetLength(), pPipelines->GetHandlePointer(), createInfoCount, std::move(handle_info), &CommonObjectInfoTable::AddVkPipelineInfo);
 }
 
 void VulkanReplayConsumer::Process_vkGetRayTracingShaderGroupHandlesKHR(

framework/generated/generated_vulkan_replay_consumer.cpp

@@ -57,6 +57,7 @@
     "vkCreateShaderModule": "OverrideCreateShaderModule",
     "vkGetPipelineCacheData": "OverrideGetPipelineCacheData",
     "vkCreatePipelineCache": "OverrideCreatePipelineCache",
+    "vkDestroyPipelineCache": "OverrideDestroyPipelineCache",
     "vkResetDescriptorPool": "OverrideResetDescriptorPool",
     "vkCreateDescriptorUpdateTemplate": "OverrideCreateDescriptorUpdateTemplate",
     "vkCreateDescriptorUpdateTemplateKHR": "OverrideCreateDescriptorUpdateTemplate",
@@ -93,6 +94,7 @@
     "vkGetBufferDeviceAddressKHR": "OverrideGetBufferDeviceAddress",
     "vkGetBufferDeviceAddressEXT": "OverrideGetBufferDeviceAddress",
     "vkGetAccelerationStructureDeviceAddressKHR": "OverrideGetAccelerationStructureDeviceAddressKHR",
+    "vkCreateRayTracingPipelinesNV": "OverrideCreateRayTracingPipelinesNV",
     "vkGetRayTracingShaderGroupHandlesKHR": "OverrideGetRayTracingShaderGroupHandlesKHR",
     "vkGetAndroidHardwareBufferPropertiesANDROID": "OverrideGetAndroidHardwareBufferPropertiesANDROID",
     "vkDeferredOperationJoinKHR": "OverrideDeferredOperationJoinKHR",

framework/generated/khronos_generators/vulkan_generators/replay_overrides.json

@@ -36,15 +36,16 @@ const char kOptions[] =
     "--dump-resources-dump-depth-attachment,--dump-"
     "resources-dump-vertex-index-buffers,--dump-resources-json-output-per-command,--dump-resources-dump-immutable-"
     "resources,--dump-resources-dump-all-image-subresources,--dump-resources-dump-raw-images,--dump-resources-dump-"
-    "separate-alpha,--pbi-all,--preload-measurement-range";
+    "separate-alpha,--pbi-all,--preload-measurement-range, --add-new-pipeline-caches";
 const char kArguments[] =
     "--log-level,--log-file,--gpu,--gpu-group,--pause-frame,--wsi,--surface-index,-m|--memory-translation,"
     "--replace-shaders,--screenshots,--denied-messages,--allowed-messages,--screenshot-format,--"
     "screenshot-dir,--screenshot-prefix,--screenshot-size,--screenshot-scale,--mfr|--measurement-frame-range,--fw|--"
     "force-windowed,--fwo|--force-windowed-origin,--batching-memory-usage,--measurement-file,--swapchain,--sgfs|--skip-"
     "get-fence-status,--sgfr|--"
     "skip-get-fence-ranges,--dump-resources,--dump-resources-scale,--dump-resources-image-format,--dump-resources-dir,"
-    "--dump-resources-dump-color-attachment-index,--pbis,--pcj|--pipeline-creation-jobs";
+    "--dump-resources-dump-color-attachment-index,--pbis,--pcj|--pipeline-creation-jobs,--save-pipeline-cache,--load-"
+    "pipeline-cache";
 
 static void PrintUsage(const char* exe_name)
 {
@@ -332,6 +333,18 @@ static void PrintUsage(const char* exe_name)
     GFXRECON_WRITE_CONSOLE("          \t\tIf <num_jobs> is negative it will be added to the number of cpu-cores");
     GFXRECON_WRITE_CONSOLE("          \t\tDefault: 0 (do not use asynchronous operations).");
     GFXRECON_WRITE_CONSOLE("          \t\tSame as --pcj <num_jobs>");
+    GFXRECON_WRITE_CONSOLE("  --save-pipeline-cache <cache-file>");
+    GFXRECON_WRITE_CONSOLE("          \t\tIf set, produces pipeline caches at replay time instead of using");
+    GFXRECON_WRITE_CONSOLE("          \t\tthe one saved at capture time and save those caches in <cache-file>.");
+    GFXRECON_WRITE_CONSOLE("  --load-pipeline-cache <cache-file>");
+    GFXRECON_WRITE_CONSOLE("          \t\tIf set, loads data created by the `--save-pipeline-cache`");
+    GFXRECON_WRITE_CONSOLE("          \t\toption in <cache-file> and uses it to create the pipelines instead");
+    GFXRECON_WRITE_CONSOLE("          \t\tof the pipeline caches saved at capture time.");
+    GFXRECON_WRITE_CONSOLE("  --add-new-pipeline-caches");
+    GFXRECON_WRITE_CONSOLE("          \t\tIf set, allows gfxreconstruct to create new vkPipelineCache objects");
+    GFXRECON_WRITE_CONSOLE("          \t\twhen it encounters a pipeline created without cache. This option can");
+    GFXRECON_WRITE_CONSOLE("          \t\tbe used in coordination with `--save-pipeline-cache` and");
+    GFXRECON_WRITE_CONSOLE("          \t\t`--load-pipeline-cache`.");
 #if defined(WIN32)
     GFXRECON_WRITE_CONSOLE("")
     GFXRECON_WRITE_CONSOLE("D3D12 only:")

tools/replay/replay_settings.h

@@ -124,6 +124,9 @@ const char kPrintBlockInfoAllOption[]             = "--pbi-all";
 const char kPrintBlockInfosArgument[]             = "--pbis";
 const char kNumPipelineCreationJobs[]             = "--pipeline-creation-jobs";
 const char kPreloadMeasurementRangeOption[]       = "--preload-measurement-range";
+const char kSavePipelineCacheArgument[]           = "--save-pipeline-cache";
+const char kLoadPipelineCacheArgument[]           = "--load-pipeline-cache";
+const char kCreateNewPipelineCacheOption[]        = "--add-new-pipeline-caches";
 #if defined(WIN32)
 const char kDxTwoPassReplay[]             = "--dx12-two-pass-replay";
 const char kDxOverrideObjectNames[]       = "--dx12-override-object-names";
@@ -1109,6 +1112,10 @@ GetVulkanReplayOptions(const gfxrecon::util::ArgumentParser&           arg_parse
         replay_options.dump_resources_color_attachment_index = std::stoi(dr_color_att_idx);
     }
 
+    replay_options.save_pipeline_cache_filename = arg_parser.GetArgumentValue(kSavePipelineCacheArgument);
+    replay_options.load_pipeline_cache_filename = arg_parser.GetArgumentValue(kLoadPipelineCacheArgument);
+    replay_options.add_new_pipeline_caches      = arg_parser.IsOptionSet(kCreateNewPipelineCacheOption);
+
     return replay_options;
 }