Add --flush-inside-measurement-range option

Add option to flush and wait all current GPU work to finish
at the end of every frame inside the measurement range.

This allows to take measurements on each frame individually
without jobs interleaving between two frames.

Change-Id: I5e55fcfc33c4baa344445a963fedbe80e94c925c

Author: marius-pelegrin-arm

framework/decode/replay_options.h

@@ -47,6 +47,7 @@ struct ReplayOptions
     bool     omit_null_hardware_buffers{ false };
     bool     quit_after_measurement_frame_range{ false };
     bool     flush_measurement_frame_range{ false };
+    bool     flush_inside_measurement_range{ false };
     bool     force_windowed{ false };
     uint32_t windowed_width{ 0 };
     uint32_t windowed_height{ 0 };

framework/graphics/fps_info.cpp

@@ -58,11 +58,13 @@ FpsInfo::FpsInfo(uint64_t measurement_start_frame,
                  uint64_t measurement_end_frame,
                  bool     has_measurement_range,
                  bool     quit_after_range,
-                 bool     flush_measurement_range) :
+                 bool     flush_measurement_range,
+                 bool     flush_inside_measurement_range) :
     measurement_start_frame_(measurement_start_frame),
     measurement_end_frame_(measurement_end_frame), measurement_start_time_(0), measurement_end_time_(0),
     quit_after_range_(quit_after_range), flush_measurement_range_(flush_measurement_range),
-    has_measurement_range_(has_measurement_range), started_measurement_(false), ended_measurement_(false)
+    flush_inside_measurement_range_(flush_inside_measurement_range), has_measurement_range_(has_measurement_range),
+    started_measurement_(false), ended_measurement_(false)
 {}
 
 void FpsInfo::BeginFile()
@@ -109,8 +111,9 @@ void FpsInfo::EndFrame(uint64_t frame)
 
 bool FpsInfo::ShouldWaitIdleAfterFrame(uint64_t frame)
 {
-    bool range_ended = frame == measurement_end_frame_;
-    return flush_measurement_range_ && range_ended;
+    bool range_ended  = frame == measurement_end_frame_;
+    bool inside_range = frame >= measurement_start_frame_ && frame <= measurement_end_frame_;
+    return (flush_measurement_range_ && range_ended) || (flush_inside_measurement_range_ && inside_range);
 }
 
 void FpsInfo::EndFile(uint64_t frame)

framework/graphics/fps_info.h

@@ -35,11 +35,12 @@ GFXRECON_BEGIN_NAMESPACE(graphics)
 class FpsInfo
 {
   public:
-    FpsInfo(uint64_t measurement_start_frame = 1,
-            uint64_t measurement_end_frame   = std::numeric_limits<uint64_t>::max(),
-            bool     has_measurement_range   = false,
-            bool     quit_after_range        = false,
-            bool     flush_measurement_range = false);
+    FpsInfo(uint64_t measurement_start_frame        = 1,
+            uint64_t measurement_end_frame          = std::numeric_limits<uint64_t>::max(),
+            bool     has_measurement_range          = false,
+            bool     quit_after_range               = false,
+            bool     flush_measurement_range        = false,
+            bool     flush_inside_measurement_range = false);
 
     void LogToConsole();
 
@@ -67,6 +68,7 @@ class FpsInfo
     bool has_measurement_range_;
     bool quit_after_range_;
     bool flush_measurement_range_;
+    bool flush_inside_measurement_range_;
 
     bool started_measurement_;
     bool ended_measurement_;

tools/replay/android_main.cpp

@@ -124,7 +124,8 @@ void android_main(struct android_app* app)
                                                      static_cast<uint64_t>(end_frame),
                                                      has_mfr,
                                                      replay_options.quit_after_measurement_frame_range,
-                                                     replay_options.flush_measurement_frame_range);
+                                                     replay_options.flush_measurement_frame_range,
+                                                     replay_options.flush_inside_measurement_range);
 
                 replay_consumer.SetFatalErrorHandler([](const char* message) { throw std::runtime_error(message); });
                 replay_consumer.SetFpsInfo(&fps_info);

tools/replay/desktop_main.cpp

@@ -146,19 +146,22 @@ int main(int argc, const char** argv)
             bool has_mfr                            = false;
             bool quit_after_measurement_frame_range = false;
             bool flush_measurement_frame_range      = false;
+            bool flush_inside_measurement_range     = false;
 
             if (vulkan_replay_options.enable_vulkan)
             {
                 has_mfr                            = GetMeasurementFrameRange(arg_parser, start_frame, end_frame);
                 quit_after_measurement_frame_range = vulkan_replay_options.quit_after_measurement_frame_range;
                 flush_measurement_frame_range      = vulkan_replay_options.flush_measurement_frame_range;
+                flush_inside_measurement_range     = vulkan_replay_options.flush_inside_measurement_range;
             }
 
             gfxrecon::graphics::FpsInfo fps_info(static_cast<uint64_t>(start_frame),
                                                  static_cast<uint64_t>(end_frame),
                                                  has_mfr,
                                                  quit_after_measurement_frame_range,
-                                                 flush_measurement_frame_range);
+                                                 flush_measurement_frame_range,
+                                                 flush_inside_measurement_range);
 
             gfxrecon::decode::VulkanReplayConsumer vulkan_replay_consumer(application, vulkan_replay_options);
             gfxrecon::decode::VulkanDecoder        vulkan_decoder;

tools/replay/replay_settings.h

@@ -30,8 +30,8 @@ const char kOptions[] =
     "-h|--help,--version,--log-debugview,--no-debug-popup,--paused,--sync,--sfa|--skip-failed-allocations,--"
     "opcd|--omit-pipeline-cache-data,--remove-unsupported,--validate,--debug-device-lost,--create-dummy-allocations,--"
     "screenshot-all,--onhb|--omit-null-hardware-buffers,--qamr|--quit-after-measurement-"
-    "range,--fmr|--flush-measurement-range,--use-captured-swapchain-indices,--dcp,--discard-cached-psos,"
-    "--dx12-override-object-names";
+    "range,--fmr|--flush-measurement-range,--flush-inside-measurement-range,--use-captured-swapchain-indices,--dcp,--"
+    "discard-cached-psos,--dx12-override-object-names";
 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,--"
@@ -191,6 +191,10 @@ static void PrintUsage(const char* exe_name)
     GFXRECON_WRITE_CONSOLE("          \t\tIf this is specified the replayer will flush")
     GFXRECON_WRITE_CONSOLE("          \t\tand wait for all current GPU work to finish at the");
     GFXRECON_WRITE_CONSOLE("          \t\tstart and end of the measurement range.");
+    GFXRECON_WRITE_CONSOLE("  --flush-inside-measurement-range");
+    GFXRECON_WRITE_CONSOLE("          \t\tIf this is specified the replayer will flush")
+    GFXRECON_WRITE_CONSOLE("          \t\tand wait for all current GPU work to finish at the");
+    GFXRECON_WRITE_CONSOLE("          \t\tend of each frame inside the measurement range.");
     GFXRECON_WRITE_CONSOLE("  --gpu-group <index>\t\tUse the specified device group for replay, where index");
     GFXRECON_WRITE_CONSOLE("          \t\tis the zero-based index to the array of physical device group");
     GFXRECON_WRITE_CONSOLE("          \t\treturned by vkEnumeratePhysicalDeviceGroups.  Replay may fail");

tools/tool_settings.h

@@ -99,6 +99,7 @@ const char kOutput[]                             = "--output";
 const char kMeasurementRangeArgument[]           = "--measurement-frame-range";
 const char kQuitAfterMeasurementRangeOption[]    = "--quit-after-measurement-range";
 const char kFlushMeasurementRangeOption[]        = "--flush-measurement-range";
+const char kFlushInsideMeasurementRangeOption[]  = "--flush-inside-measurement-range";
 const char kEnableUseCapturedSwapchainIndices[]  = "--use-captured-swapchain-indices";
 const char kFormatArgument[]                     = "--format";
 const char kIncludeBinariesOption[]              = "--include-binaries";
@@ -710,6 +711,11 @@ static void GetReplayOptions(gfxrecon::decode::ReplayOptions& options, const gfx
         options.flush_measurement_frame_range = true;
     }
 
+    if (arg_parser.IsOptionSet(kFlushInsideMeasurementRangeOption))
+    {
+        options.flush_inside_measurement_range = true;
+    }
+
     const auto& override_gpu = arg_parser.GetArgumentValue(kOverrideGpuArgument);
     if (!override_gpu.empty())
     {