Merge branch 'ajaus/input-ping-main' into 'main'

[REMIX-5970] Keep an unfocused window's input queue serviced by generating WM_NULL every 2 seconds

See merge request lightspeedrtx/dxvk-remix-nv!2328

Author: nv-ajaus

RtxOptions.md

@@ -230,6 +230,7 @@ This file is auto-generated by RTX Remix. To regenerate it, run Remix with `DXVK
 |rtx.enableIndexBufferMemoization|bool|True|||CPU performance optimization, should generally be enabled\.  Will reduce main thread time by caching processIndexBuffer operations and reusing when possible, this will come at the expense of some CPU RAM\.|
 |rtx.enableIndirectAlphaBlendShadows|bool|True|||Calculate shadows for semi\-transparent \(alpha blended\) objects in indirect lighting \(i\.e\. reflections and GI\)\. In engineering terms: include OBJECT\_MASK\_ALPHA\_BLEND into secondary visibility rays\.|
 |rtx.enableIndirectTranslucentShadows|bool|False|||Calculate coloured shadows for translucent materials \(i\.e\. glass, water\) in indirect lighting \(i\.e\. reflections and GI\)\. In engineering terms: include OBJECT\_MASK\_TRANSLUCENT into secondary visibility rays\.|
+|rtx.enableInputQueuePing|bool|False|||When enabled, Remix posts a WM\_NULL message to the game window every rtx\.inputQueuePingIntervalMs milliseconds so Windows keeps servicing the window's input queue and does not flag the game as not responding while it presents without focus\.<br>This setting is read when the swapchain is created; changing it will not take effect at runtime\.|
 |rtx.enableInstanceDebuggingTools|bool|False|||NOTE: This will disable temporal correllation for instances, but allow the use of instance developer debug tools|
 |rtx.enableLegacyRectLightConeShaping|bool|False|||If true, restores the legacy cos\(angle\) \* aspectRatio formula for RectLight cone shaping\. Enable this only to preserve the look of existing scenes that were authored against the legacy behavior\. Note this can silently kill the light at high aspect ratios\.|
 |rtx.enableMultiStageTextureFactorBlending|bool|True|||Support texture factor blending in stage 1~7\. Currently only support 1 additional blending stage, more than 1 additional blending stages will be ignored\.|
@@ -319,6 +320,7 @@ This file is auto-generated by RTX Remix. To regenerate it, run Remix with `DXVK
 |rtx.initializer.asyncAssetLoading|bool|True|||If true, a separate thread is created to load USD assets asynchronously\.|
 |rtx.initializer.asyncShaderFinalizing|bool|True|||When set to true, shader prewarming will be finalized asynchronously rather than Remix's initializer blocking synchronously until it is finished\.<br>Do note that this only controls if Remix waits for prewarming to finish or not on startup, if shaders are not finished prewarming by the time they are first used by Remix \(e\.g\. once ray tracing starts\) they will still block synchronously until finished even with this option set\. See rtx\.shader\.enableAsyncCompilation for true async shader compilation\.<br>This option should usually be set to true and is usually combined with async shader compilation to faciliate a better user experience, but can be to set to false to ensure all shaders are loaded to allow for slightly more deterministic behavior when debugging, or if prewarming all shaders before rendering is desired behavior \(at the cost of blocking on startup for a while\)\.<br>Finally, this option only takes effect for the most part when shader prewarming is enabled \(rtx\.initializer\.asyncShaderPrewarming\) as otherwise there will be no prewarmed shaders to worry about finalizing\.|
 |rtx.initializer.asyncShaderPrewarming|bool|True|||When set to true, shader prewarming will be enabled, allowing for Remix to start compiling shaders before their first use\.<br>Typically shaders will only begin compilation on their first use, but this is generally undesirable from a user experience perspective as this often causes stalls or wait times while using the application until all shaders have been used at least once\.<br>By prewarming permutations of potentially required shaders in advance this can be avoided by ensuring all required shaders are compiled before they are used\.<br>Additionally, this prewarming work can often be overlapped with an application's existing startup sequence \(e\.g\. the initial loading screen of a game\), allowing Remix's shaders to be ready before they are actually used and avoiding any stalls or wait times\.<br>As such this should generally be set to true and is often used in conjunction with rtx\.initializer\.asyncShaderFinalizing to avoid Remix blocking on initialization for the prewarming to complete, and rtx\.shader\.enableAsyncCompilation to avoid shaders from blocking if the application starts using Remix shaders before prewarming is complete\.<br>Since prewarming uses shader permutation however a greater amount of shaders will need to be compiled when this option is enabled compared to the minimal required set \(mainly to accomodate various runtime situations and user\-facing options that may be altered\)\. Setting this option to false may be useful in specific cases where minimizing this compilation cost is important over user experience \(e\.g\. for automated testing\)\.|
+|rtx.inputQueuePingIntervalMs|int|2000|1||Interval in milliseconds between WM\_NULL pings when rtx\.enableInputQueuePing is enabled\. Unlike the enable flag, this is re\-read by the ping thread every iteration, so changes take effect after at most one interval\.|
 |rtx.instanceOverrideInstanceIdx|int|-1||||
 |rtx.instanceOverrideInstanceIdxRange|int|15||||
 |rtx.instanceOverrideSelectedInstancePrintMaterialHash|bool|False||||

src/d3d9/d3d9_swapchain.cpp

@@ -370,10 +370,28 @@ namespace dxvk {
     } else {
       HookWindowProc(m_window);
     }
+
+    // NV-DXVK start: input-queue liveness ping
+    if (m_window && enableInputQueuePing()) {
+      m_inputPingThread = dxvk::thread([this] { RunInputQueuePing(); });
+    }
+    // NV-DXVK end
   }
 
 
   D3D9SwapChainEx::~D3D9SwapChainEx() {
+    // NV-DXVK start: input-queue liveness ping
+    if (m_inputPingThread.joinable()) {
+      {
+        std::lock_guard<dxvk::mutex> lock(m_inputPingMutex);
+        m_inputPingStop = true;
+      }
+
+      m_inputPingCond.notify_one();
+      m_inputPingThread.join();
+    }
+    // NV-DXVK end
+
     DestroyBackBuffers();
 
     ResetWindowProc(m_window);
@@ -1574,6 +1592,49 @@ namespace dxvk {
   }
 
 
+  // NV-DXVK start
+  // Generate a WM_NULL message every few seconds to keep Windows from inaccurately 
+  // declaring the host application to be not responsive
+  void D3D9SwapChainEx::RunInputQueuePing() {
+    env::setThreadName("dxvk-input-ping");
+
+#ifdef REMIX_DEVELOPMENT
+    bool wasHung = false;
+#endif
+
+    while (true) {
+      const auto interval = std::chrono::milliseconds(inputQueuePingIntervalMs());
+
+      {
+        std::unique_lock<dxvk::mutex> lock(m_inputPingMutex);
+
+        if (m_inputPingCond.wait_for(lock, interval, [this] { return m_inputPingStop; })) {
+          return;
+        }
+      }
+
+      if (!IsWindow(m_window)) {
+        continue;
+      }
+
+#ifdef REMIX_DEVELOPMENT
+      // The classifier's verdict is the validity gate for this ping: a run that
+      // never logs is a run where the ping is working.
+      const bool hung = IsHungAppWindow(m_window);
+
+      if (hung != wasHung) {
+        Logger::info(str::format("Input queue ping: window ",
+                                 hung ? "flagged as not responding" : "responding"));
+        wasHung = hung;
+      }
+#endif
+
+      PostMessageW(m_window, WM_NULL, 0, 0);
+    }
+  }
+  // NV-DXVK end
+
+
   uint32_t D3D9SwapChainEx::GetActualFrameLatency() {
     uint32_t maxFrameLatency = m_parent->GetFrameLatency();
 

src/d3d9/d3d9_swapchain.h

@@ -33,6 +33,11 @@
 #include "../dxvk/dxvk_swapchain_blitter.h"
 
 #include "../util/sync/sync_signal.h"
+#include "../util/thread.h"
+
+// NV-DXVK start: input-queue liveness ping
+#include "../dxvk/rtx_render/rtx_options.h"
+// NV-DXVK end
 
 #include <vector>
 
@@ -123,6 +128,21 @@ namespace dxvk {
       return m_device;
     }
 
+    // NV-DXVK start: input-queue liveness ping, see RunInputQueuePing
+    RTX_OPTION("rtx", bool, enableInputQueuePing, false,
+               "When enabled, Remix posts a WM_NULL message to the game window every "
+               "rtx.inputQueuePingIntervalMs milliseconds so Windows keeps servicing the window's "
+               "input queue and does not flag the game as not responding while it presents without "
+               "focus.\n"
+               "This setting is read when the swapchain is created; changing it will not take effect at runtime.");
+
+    RTX_OPTION_ARGS("rtx", uint32_t, inputQueuePingIntervalMs, 2000,
+                    "Interval in milliseconds between WM_NULL pings when rtx.enableInputQueuePing is enabled. "
+                    "Unlike the enable flag, this is re-read by the ping thread every iteration, so changes "
+                    "take effect after at most one interval.",
+                    args.minValue = static_cast<uint32_t>(1));
+    // NV-DXVK end
+
   protected:
 
     enum BindingIds : uint32_t {
@@ -181,6 +201,13 @@ namespace dxvk {
     HWND                      m_window   = nullptr;
     HMONITOR                  m_monitor  = nullptr;
 
+    // NV-DXVK start: input-queue liveness ping, see RunInputQueuePing
+    dxvk::thread              m_inputPingThread;
+    dxvk::mutex               m_inputPingMutex;
+    dxvk::condition_variable  m_inputPingCond;
+    bool                      m_inputPingStop = false;
+    // NV-DXVK end
+
     WindowState               m_windowState;
 
     uint32_t                  m_originalWidth;
@@ -196,6 +223,10 @@ namespace dxvk {
 
     void SynchronizePresent();
 
+    // NV-DXVK start: input-queue liveness ping
+    void RunInputQueuePing();
+    // NV-DXVK end
+
     void RecreateSwapChain(
         BOOL                      Vsync);