GPU Display: Implement FPS limiting to VSync rate

Author: davidrohr

GPU/GPUTracking/Definitions/GPUSettingsList.h

@@ -504,8 +504,8 @@ AddOption(rendererCompatSmoothing, bool, false, "", 0, "Use compat smoothing (if
 AddOption(drawQualityMSAA, int32_t, 0, "", 0, "MultiSample Anti Aliasing")
 AddOption(drawQualityDownsampleFSAA, int32_t, 0, "", 0, "Downsampling Anti Aliasing")
 AddOption(drawQualityVSync, bool, true, "", 0, "Enable Vertical Sync")
-AddOption(maxFPSRate, bool, false, "", 0, "Do not limit FPS but run at maximum possible rate")
-AddOption(fpsRate, int32_t, 100, "", 0, "Target frame rate (frames per second) if not running at maximum rate (0 = no limit)")
+AddOption(fpsLimit, int32_t, 1, "", 0, "FPS limit: 0 = none (maximum rate), 1 = display refresh rate (no limit without VSync), 2 = fpsRate")
+AddOption(fpsRate, int32_t, 100, "", 0, "Target frame rate (frames per second) for fpsLimit 2, or if the backend cannot limit to the refresh rate (0 = no limit)")
 AddOption(useGLIndirectDraw, bool, true, "", 0, "Use OpenGL indirect draws to reduce number of draw calls")
 AddOption(screenshotScaleFactor, int32_t, 1, "", 0, "Resolution scale factor when taking screenshots")
 AddOption(fov, int32_t, 45, "", 0, "Display FOV")

GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx

@@ -171,6 +171,15 @@ void GPUDisplayBackend::fillIndirectCmdBuffer()
   }
 }
 
+int32_t GPUDisplayBackend::fpsLimitMode() const
+{
+  const auto& cfg = mDisplay->cfgR();
+  if (cfg.fpsLimit == FPS_LIMIT_VSYNC) {
+    return !cfg.drawQualityVSync ? FPS_LIMIT_NONE : (canLimitToVSync() ? FPS_LIMIT_VSYNC : FPS_LIMIT_RATE);
+  }
+  return cfg.fpsLimit;
+}
+
 float GPUDisplayBackend::getDownsampleFactor(bool screenshot)
 {
   float factor = 1.0f;

GPU/GPUTracking/display/backend/GPUDisplayBackend.h

@@ -77,6 +77,11 @@ class GPUDisplayBackend
   virtual void ActivateColor(std::array<float, 4>& color) = 0;
   virtual void setQuality() {};
   virtual void SetVSync(bool enable) {};
+  enum fpsLimitModes : int32_t { FPS_LIMIT_NONE = 0,
+                                 FPS_LIMIT_VSYNC = 1,
+                                 FPS_LIMIT_RATE = 2 };   // Values of GPUSettingsDisplayRenderer::fpsLimit
+  virtual bool canLimitToVSync() const { return false; } // Rendering is throttled to the refresh rate with VSync (blocking buffer swap / present wait)
+  int32_t fpsLimitMode() const;                          // Effective mode: VSync limit without VSync = none, VSync limit not supported by the backend = fpsRate
   virtual bool backendNeedRedraw() { return true; }
   virtual void setDepthBuffer() = 0;
   virtual int32_t InitBackendA() = 0;

GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.h

@@ -35,6 +35,7 @@ class GPUDisplayBackendOpenGL : public GPUDisplayBackend
   ~GPUDisplayBackendOpenGL() override = default;
   int32_t ExtInit() override;
   bool CoreProfile() override;
+  bool canLimitToVSync() const override { return true; } // Buffer swap blocks with VSync
   uint32_t DepthBits() override;
 
  protected:

GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx

@@ -99,6 +99,10 @@ static vk::SurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<vk::Surfac
 vk::PresentModeKHR GPUDisplayBackendVulkan::chooseSwapPresentMode()
 {
   // Lowest latency first. VSync: no tearing, MAILBOX, then FIFO_LATEST_READY (shows the newest ready image at each vblank). No VSync: IMMEDIATE, else the same (often no IMMEDIATE on Wayland). FIFO is always supported.
+  mPresentModeForVSyncLimit = fpsLimitMode() == FPS_LIMIT_VSYNC;
+  if (mPresentModeForVSyncLimit) {
+    return vk::PresentModeKHR::eFifo; // Refresh rate limit: one frame per refresh, queue depth limited by present wait
+  }
   const bool vsync = mDisplay->cfgR().drawQualityVSync;
   const auto& available = mSwapChainDetails.presentModes;
   for (vk::PresentModeKHR mode : {vk::PresentModeKHR::eImmediate, vk::PresentModeKHR::eMailbox, vk::PresentModeKHR::eFifoLatestReady, vk::PresentModeKHR::eFifo}) {
@@ -313,6 +317,25 @@ static void clearFeatures(vk::StructureChain<T...>& chain) // Zero all feature f
   ((memset(reinterpret_cast<char*>(&chain.template get<T>()) + sizeof(VkBaseOutStructure), 0, sizeof(T) - sizeof(VkBaseOutStructure))), ...);
 }
 
+template <class T> // Enable the first available of the extensions (aliases) if the device supports the feature, chaining the feature struct in front of chain
+static bool enableOptionalFeature(vk::PhysicalDevice device, const std::vector<vk::ExtensionProperties>& available, std::initializer_list<const char*> extensions, vk::Bool32 T::* feature, T& featureStruct, std::vector<const char*>& enabledExtensions, void*& chain)
+{
+  for (const char* ext : extensions) {
+    if (std::none_of(available.begin(), available.end(), [ext](const auto& e) { return strcmp(ext, e.extensionName) == 0; })) {
+      continue;
+    }
+    if (!(device.getFeatures2<vk::PhysicalDeviceFeatures2, T>().template get<T>().*feature)) {
+      return false;
+    }
+    enabledExtensions.emplace_back(ext);
+    featureStruct.*feature = VK_TRUE;
+    featureStruct.pNext = chain;
+    chain = &featureStruct;
+    return true;
+  }
+  return false;
+}
+
 template <class... T>
 static vk::StructureChain<T...> getFeatures(vk::PhysicalDevice device, const vk::StructureChain<T...>&)
 {
@@ -536,18 +559,10 @@ void GPUDisplayBackendVulkan::createDevice()
   mSmoothLinesSupported = getFeatures(mPhysicalDevice, reqDeviceFeatures).get<vk::PhysicalDeviceVulkan14Features>().smoothLines;
   reqDeviceFeatures.get<vk::PhysicalDeviceVulkan14Features>().smoothLines = mSmoothLinesSupported;
   std::vector<const char*> deviceExtensions = reqDeviceExtensions;
-  vk::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR fifoLatestReadyFeatures{};
+  void* featureChain = &reqDeviceFeatures.get<vk::PhysicalDeviceFeatures2>();
   const std::vector<vk::ExtensionProperties> availableDeviceExtensions = mPhysicalDevice.enumerateDeviceExtensionProperties(nullptr);
-  for (const char* ext : {VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME, VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME}) { // Optional, same feature struct for both
-    if (std::any_of(availableDeviceExtensions.begin(), availableDeviceExtensions.end(), [ext](const auto& e) { return strcmp(ext, e.extensionName) == 0; })) {
-      mFifoLatestReadySupported = mPhysicalDevice.getFeatures2<vk::PhysicalDeviceFeatures2, vk::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR>().get<vk::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR>().presentModeFifoLatestReady;
-      if (mFifoLatestReadySupported) {
-        deviceExtensions.emplace_back(ext);
-        fifoLatestReadyFeatures.presentModeFifoLatestReady = VK_TRUE;
-      }
-      break;
-    }
-  }
+  vk::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR fifoLatestReadyFeatures{};
+  mFifoLatestReadySupported = enableOptionalFeature(mPhysicalDevice, availableDeviceExtensions, {VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME, VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME}, &vk::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR::presentModeFifoLatestReady, fifoLatestReadyFeatures, deviceExtensions, featureChain);
 
   updateSwapChainDetails(mPhysicalDevice);
   vk::PhysicalDeviceProperties deviceProperties = mPhysicalDevice.getProperties();
@@ -572,11 +587,7 @@ void GPUDisplayBackendVulkan::createDevice()
   vk::DeviceCreateInfo deviceCreateInfo{};
   deviceCreateInfo.pQueueCreateInfos = &queueCreateInfo;
   deviceCreateInfo.queueCreateInfoCount = 1;
-  deviceCreateInfo.pNext = &reqDeviceFeatures.get<vk::PhysicalDeviceFeatures2>();
-  if (mFifoLatestReadySupported) {
-    fifoLatestReadyFeatures.pNext = &reqDeviceFeatures.get<vk::PhysicalDeviceFeatures2>();
-    deviceCreateInfo.pNext = &fifoLatestReadyFeatures;
-  }
+  deviceCreateInfo.pNext = featureChain;
   deviceCreateInfo.pEnabledFeatures = nullptr;
   deviceCreateInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
   deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions.data();
@@ -648,13 +659,27 @@ void GPUDisplayBackendVulkan::createSemaphores()
   mTimelineValue = 0;
   mFrameTimelineValue.assign(mFramesInFlight, 0);
   mImageTimelineValue.assign(mImageCount, 0);
+  for (uint32_t i = 0; i < mImageCount; i++) {
+    mPresentFences.emplace_back(mDevice.createFence(vk::FenceCreateInfo{vk::FenceCreateFlagBits::eSignaled}, nullptr));
+  }
+}
+
+void GPUDisplayBackendVulkan::waitPresentFences()
+{
+  if (mPresentFences.size()) { // Timeout in case a failed present did not signal its fence
+    vk::Result retVal = mDevice.waitForFences(mPresentFences.size(), mPresentFences.data(), true, 1'000'000'000);
+    if (retVal != vk::Result::eTimeout) {
+      CHKERR(retVal);
+    }
+  }
 }
 
 void GPUDisplayBackendVulkan::clearSemaphores()
 {
   clearVector(mImageAvailableSemaphore, [&](auto& x) { mDevice.destroySemaphore(x, nullptr); });
   clearVector(mPresentSemaphore, [&](auto& x) { mDevice.destroySemaphore(x, nullptr); });
   mDevice.destroySemaphore(mTimelineSemaphore, nullptr);
+  clearVector(mPresentFences, [&](auto& x) { mDevice.destroyFence(x, nullptr); });
 }
 
 // ---------------------------- VULKAN UNIFORM LAYOUTS AND BUFFERS  ----------------------------
@@ -770,8 +795,23 @@ void GPUDisplayBackendVulkan::createSwapChain(vk::SwapchainKHR oldSwapChain)
   swapCreateInfo.presentMode = mPresentMode;
   swapCreateInfo.clipped = true;
   swapCreateInfo.oldSwapchain = oldSwapChain;
+  vk::SwapchainPresentScalingCreateInfoKHR scalingInfo{};
+  { // Let the compositor scale the last image while resizing, until the new swapchain is presented
+    const vk::SurfacePresentModeKHR surfacePresentMode{mPresentMode};
+    const auto caps = mPhysicalDevice.getSurfaceCapabilities2KHR<vk::SurfaceCapabilities2KHR, vk::SurfacePresentScalingCapabilitiesKHR>(vk::PhysicalDeviceSurfaceInfo2KHR{mSurface, &surfacePresentMode}).get<vk::SurfacePresentScalingCapabilitiesKHR>();
+    auto gravity = [](vk::PresentGravityFlagsKHR f) { return (f & vk::PresentGravityFlagBitsKHR::eCentered) ? vk::PresentGravityFlagBitsKHR::eCentered : (f & vk::PresentGravityFlagBitsKHR::eMin) ? vk::PresentGravityFlagBitsKHR::eMin
+                                                                                                                                                                                                   : vk::PresentGravityFlagsKHR(f & vk::PresentGravityFlagBitsKHR::eMax); };
+    scalingInfo.scalingBehavior = (caps.supportedPresentScaling & vk::PresentScalingFlagBitsKHR::eAspectRatioStretch) ? vk::PresentScalingFlagBitsKHR::eAspectRatioStretch : vk::PresentScalingFlagsKHR(caps.supportedPresentScaling & vk::PresentScalingFlagBitsKHR::eStretch);
+    scalingInfo.presentGravityX = gravity(caps.supportedPresentGravityX);
+    scalingInfo.presentGravityY = gravity(caps.supportedPresentGravityY);
+    if (scalingInfo.scalingBehavior && scalingInfo.presentGravityX && scalingInfo.presentGravityY) {
+      swapCreateInfo.pNext = &scalingInfo;
+    }
+  }
   mSwapChain = mDevice.createSwapchainKHR(swapCreateInfo, nullptr);
+  mLastPresentId = 0; // Present IDs are per swapchain
   if (oldSwapChain) {
+    waitPresentFences(); // Presentation engine done with the old swapchain
     mDevice.destroySwapchainKHR(oldSwapChain, nullptr);
   }
 
@@ -809,6 +849,7 @@ void GPUDisplayBackendVulkan::clearSwapChain(bool keepSwapChain)
 {
   clearVector(mSwapChainImageViews, [&](auto& x) { mDevice.destroyImageView(x, nullptr); });
   if (!keepSwapChain) {
+    waitPresentFences();
     mDevice.destroySwapchainKHR(mSwapChain, nullptr);
   }
 }
@@ -1424,11 +1465,22 @@ void GPUDisplayBackendVulkan::prepareDraw(const hmm_mat4& proj, const hmm_mat4&
   if (includeMixImage == 0.f) {
     mCurrentFrame = (mCurrentFrame + 1) % mFramesInFlight;
     waitTimeline(mFrameTimelineValue[mCurrentFrame]);
+    if (mLastPresentId > 1 && fpsLimitMode() == FPS_LIMIT_VSYNC) { // Refresh rate limit (FIFO): at most one frame queued (wait for the second-last present), keeps the rate if a frame misses the deadline, timeout in case the window is hidden
+      const vk::Result retVal = (vk::Result)VULKAN_HPP_DEFAULT_DISPATCHER.vkWaitForPresentKHR(static_cast<VkDevice>(mDevice), static_cast<VkSwapchainKHR>(mSwapChain), mLastPresentId - 1, 100'000'000);
+      if (retVal == vk::Result::eErrorOutOfDateKHR || retVal == vk::Result::eSuboptimalKHR) {
+        mMustUpdateSwapChain = true;
+      } else if (retVal != vk::Result::eTimeout) {
+        CHKERR(retVal);
+      }
+    }
     auto getImage = [&]() {
       return mDevice.acquireNextImageKHR(mSwapChain, UINT64_MAX, mImageAvailableSemaphore[mCurrentFrame], VkFence(VK_NULL_HANDLE), &mCurrentImageIndex);
     };
 
     vk::Result retVal = vk::Result::eSuccess;
+    if (mPresentModeForVSyncLimit != (fpsLimitMode() == FPS_LIMIT_VSYNC)) { // Present mode depends on the FPS limit mode
+      mMustUpdateSwapChain = true;
+    }
     bool mustUpdateSwapChain = mMustUpdateSwapChain || mDisplay->updateRenderPipeline() || (toMixBuffer && !mMixingSupported) || mDownsampleFactor != getDownsampleFactor(requestScreenshot) || mSmoothLines != useNativeSmoothLines();
     if (!mustUpdateSwapChain) {
       retVal = getImage();
@@ -1442,7 +1494,11 @@ void GPUDisplayBackendVulkan::prepareDraw(const hmm_mat4& proj, const hmm_mat4&
     }
     mMustUpdateSwapChain = retVal == vk::Result::eSuboptimalKHR;
     CHKERR(retVal);
-    waitTimeline(mImageTimelineValue[mCurrentImageIndex]); // Previous frame using this image's resources (command buffers, uniform buffer, ...) finished
+    waitTimeline(mImageTimelineValue[mCurrentImageIndex]);                                        // Previous frame using this image's resources (command buffers, uniform buffer, ...) finished
+    if (mPresentFences.size()) {                                                                  // Previous present of this image done, its present semaphore can be signaled again
+      CHKERR(mDevice.waitForFences(1, &mPresentFences[mCurrentImageIndex], true, 1'000'000'000)); // Timeout (positive result, not an error) in case a failed present did not signal it
+      CHKERR(mDevice.resetFences(1, &mPresentFences[mCurrentImageIndex]));
+    }
 
     mHasDrawnText = false;
     mFrameCommandBuffers.clear();
@@ -1521,6 +1577,17 @@ void GPUDisplayBackendVulkan::finishFrame(bool doScreenshot, bool toMixBuffer, f
     presentInfo.pSwapchains = &mSwapChain;
     presentInfo.pImageIndices = &mCurrentImageIndex;
     presentInfo.pResults = nullptr;
+    const uint64_t presentId = mLastPresentId + 1;
+    vk::PresentIdKHR presentIdInfo{1, &presentId};
+    if (fpsLimitMode() == FPS_LIMIT_VSYNC) { // Present wait only for the refresh rate limit, the fpsRate limit (frontend timer) must not be capped at the refresh rate
+      presentInfo.pNext = &presentIdInfo;
+      mLastPresentId = presentId;
+    }
+    vk::SwapchainPresentFenceInfoKHR presentFenceInfo{};
+    if (mPresentFences.size()) {
+      presentFenceInfo = vk::SwapchainPresentFenceInfoKHR{1, &mPresentFences[mCurrentImageIndex], presentInfo.pNext};
+      presentInfo.pNext = &presentFenceInfo;
+    }
     vk::Result retVal = mGraphicsQueue.presentKHR(&presentInfo);
     if (retVal == vk::Result::eErrorOutOfDateKHR || retVal == vk::Result::eSuboptimalKHR) {
       mMustUpdateSwapChain = true;

GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.h

@@ -83,6 +83,8 @@ class GPUDisplayBackendVulkan : public GPUDisplayBackend
   void lineWidthFactor(float factor) override;
   bool useNativeSmoothLines() const;
   bool useSmoothLineShader() const;
+  bool canLimitToVSync() const override { return true; } // Present wait
+  void waitPresentFences();
   void resizeScene(uint32_t width, uint32_t height) override;
   float getYFactor() const override { return -1.0f; }
   int32_t getMaxMSAA() const override { return mMaxMSAAsupported; }
@@ -208,16 +210,21 @@ class GPUDisplayBackendVulkan : public GPUDisplayBackend
   vecpod<float> mFontVertexBufferHost;
   bool mHasDrawnText = false;
 
-  vk::SampleCountFlagBits mMSAASampleCount = vk::SampleCountFlagBits::e16;
+  // Device capabilities, set in createDevice (optional features are enabled only if supported)
   uint32_t mMaxMSAAsupported = 0;
+  bool mZSupported = false;
+  bool mStencilSupported = false;
+  bool mStrictLines = false;              // Wide lines are rectangles, not parallelograms
+  bool mSmoothLinesSupported = false;     // Optional Vulkan 1.4 feature smoothLines
+  bool mFifoLatestReadySupported = false; // Optional present mode FIFO_LATEST_READY (VK_KHR / VK_EXT_present_mode_fifo_latest_ready)
+
+  vk::SampleCountFlagBits mMSAASampleCount = vk::SampleCountFlagBits::e16;
   bool mZActive = false;
-  bool mSmoothLinesSupported = false; // Optional Vulkan 1.4 feature smoothLines, enabled if available
   bool mSmoothLines = false;
   bool mPresentModeErrorShown = false;
-  bool mFifoLatestReadySupported = false; // Optional present mode FIFO_LATEST_READY (VK_KHR / VK_EXT_present_mode_fifo_latest_ready), enabled if available
-  bool mStrictLines = false;
-  bool mZSupported = false;
-  bool mStencilSupported = false;
+  bool mPresentModeForVSyncLimit = false; // Swapchain created with FIFO for the refresh rate FPS limit
+  std::vector<vk::Fence> mPresentFences;  // Per swapchain image, signaled when its last present is done (swapchain_maintenance1)
+  uint64_t mLastPresentId = 0;            // Last present ID of the current swapchain, 0 = none
   bool mDownsampleFSAA = false;
   bool mMixingSupported = 0;
 

GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx

@@ -81,7 +81,7 @@ void GPUDisplayFrontend::waitForFPSLimit()
   mNeedUpdate = 0;
   const auto now = std::chrono::steady_clock::now();
   const auto& cfg = mDisplay->cfgR();
-  if (cfg.maxFPSRate || cfg.fpsRate <= 0) {
+  if (mBackend->fpsLimitMode() != GPUDisplayBackend::FPS_LIMIT_RATE || cfg.fpsRate <= 0) {
     mNextFrameTime = now;
     return;
   }

GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h

@@ -61,6 +61,7 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
   GPUDisplayBackend* backend();
   static GPUDisplayFrontend* getFrontend(const char* type);
   virtual void getSize(int32_t& width, int32_t& height) { width = height = 0; }
+  virtual float getRefreshRate() { return 0.f; }        // Refresh rate of the display the window is on in Hz, 0 = unknown
   virtual float getDisplayScale() const { return 1.f; } // HiDPI scale factor: physical pixels per logical pixel, text positions and sizes are scaled by it
   virtual int32_t getVulkanSurface(void* instance, void* surface) { return 1; }
   virtual uint32_t getReqVulkanExtensions(const char**& p) { return 0; };
@@ -80,7 +81,7 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
   virtual int32_t FrontendMain() = 0;
   virtual void StopDisplayA();
   static void* FrontendThreadWrapper(void*);
-  void waitForFPSLimit(); // Sleep until the next frame is due according to fpsRate (no sleep with maxFPSRate or fpsRate <= 0)
+  void waitForFPSLimit(); // Sleep until the next frame is due according to fpsRate (only in FPS_LIMIT_RATE mode, see GPUDisplayBackend::fpsLimitMode)
 
   static constexpr int32_t INIT_WIDTH = 1024, INIT_HEIGHT = 768;                        // Initial window size, before maximizing
   static constexpr int32_t MIN_WIDTH = 200, MIN_HEIGHT = 150;                           // Minimum window size

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx

@@ -396,6 +396,13 @@ bool GPUDisplayFrontendGlfw::EnableSendKey()
   return true;
 }
 
+float GPUDisplayFrontendGlfw::getRefreshRate()
+{
+  GLFWmonitor* monitor = glfwGetWindowMonitor(mWindow) ? glfwGetWindowMonitor(mWindow) : glfwGetPrimaryMonitor(); // Monitor of a windowed window is not known, use the primary one
+  const GLFWvidmode* mode = monitor ? glfwGetVideoMode(monitor) : nullptr;
+  return mode ? mode->refreshRate : 0.f;
+}
+
 void GPUDisplayFrontendGlfw::getSize(int32_t& width, int32_t& height)
 {
   glfwGetFramebufferSize(mWindow, &width, &height);

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.h

@@ -35,6 +35,7 @@ class GPUDisplayFrontendGlfw : public GPUDisplayFrontend
   bool EnableSendKey() override;
   void getSize(int32_t& width, int32_t& height) override;
   float getDisplayScale() const override { return mScale; }
+  float getRefreshRate() override;
   int32_t getVulkanSurface(void* instance, void* surface) override;
   uint32_t getReqVulkanExtensions(const char**& p) override;