GPU Display: Better implementation of FPS limiting

Author: davidrohr

GPU/GPUTracking/Definitions/GPUSettingsList.h

@@ -504,7 +504,8 @@ AddOption(openGLCore, bool, false, "", 0, "Use renderer path for OpenGL core pro
 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, int32_t, 0, "", 0, "Do not limit FPS but run at maximum possible rate")
+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(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/Interface/GPUO2InterfaceDisplay.cxx

@@ -74,6 +74,9 @@ int32_t GPUO2InterfaceDisplay::show(const GPUTrackingInOutPointers* ptrs)
 int32_t GPUO2InterfaceDisplay::endDisplay()
 {
   mFrontend->DisplayExit();
+  while (mFrontend->IsRunning()) {
+    usleep(10000);
+  }
   return 0;
 }
 

GPU/GPUTracking/display/GPUDisplayInterface.h

@@ -60,10 +60,9 @@ class GPUDisplayFrontendInterface
   virtual bool EnableSendKey() = 0;
   virtual int32_t getDisplayControl() const = 0;
   virtual int32_t getSendKey() const = 0;
-  virtual int32_t getNeedUpdate() const = 0;
   virtual void setDisplayControl(int32_t v) = 0;
+  virtual bool IsRunning() const = 0;
   virtual void setSendKey(int32_t v) = 0;
-  virtual void setNeedUpdate(int32_t v) = 0;
   virtual const char* frontendName() const = 0;
 
  protected:

GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx

@@ -1404,7 +1404,7 @@ void GPUDisplayBackendVulkan::clearImage(VulkanImage& image)
 
 int32_t GPUDisplayBackendVulkan::InitBackendA()
 {
-  mEnableValidationLayers = mDisplay->param() && mDisplay->GetProcessingSettings().debugLevel >= 2;
+  mEnableValidationLayers = (mDisplay->param() && mDisplay->GetProcessingSettings().debugLevel >= 2) || (getenv("GPUCA_VULKAN_VALIDATION") && atoi(getenv("GPUCA_VULKAN_VALIDATION")));
   mFramesInFlight = 2;
 
   createDevice();

GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx

@@ -37,6 +37,7 @@
 
 #include "GPULogging.h"
 #include <cstring>
+#include <thread>
 
 #ifdef GPUCA_BUILD_EVENT_DISPLAY_QT
 #include "GPUDisplayGUIWrapper.h"
@@ -63,6 +64,23 @@ void* GPUDisplayFrontend::FrontendThreadWrapper(void* ptr)
   return ((void*)(size_t)retVal);
 }
 
+void GPUDisplayFrontend::waitForFPSLimit()
+{
+  mNeedUpdate = 0;
+  const auto now = std::chrono::steady_clock::now();
+  const auto& cfg = mDisplay->cfgR();
+  if (cfg.maxFPSRate || cfg.fpsRate <= 0) {
+    mNextFrameTime = now;
+    return;
+  }
+  const auto period = std::chrono::duration_cast<std::chrono::steady_clock::duration>(std::chrono::duration<double>(1. / cfg.fpsRate));
+  mNextFrameTime += period;
+  if (mNextFrameTime < now - period) { // More than one frame behind (slow rendering, first frame), do not try to catch up
+    mNextFrameTime = now;
+  }
+  std::this_thread::sleep_until(mNextFrameTime);
+}
+
 void GPUDisplayFrontend::HandleSendKey()
 {
   if (mSendKey) {
@@ -73,6 +91,7 @@ void GPUDisplayFrontend::HandleSendKey()
 
 void GPUDisplayFrontend::HandleKey(uint8_t key) { mDisplay->HandleKey(key); }
 int32_t GPUDisplayFrontend::DrawGLScene() { return mDisplay->DrawGLScene(); }
+
 void GPUDisplayFrontend::ResizeScene(int32_t width, int32_t height)
 {
   mDisplayHeight = height;

GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h

@@ -18,6 +18,7 @@
 #include "GPUCommonDef.h"
 #include "GPUDisplayInterface.h"
 #include <memory>
+#include <chrono>
 
 namespace o2::gpu
 {
@@ -49,7 +50,8 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
   static constexpr int32_t GL_MIN_VERSION_MINOR = 5;
 
   int32_t StartDisplay();                                                                                                    // Start the display. This function returns, and should spawn a thread that runs the display, and calls InitDisplay
-  void DisplayExit() override = 0;                                                                                           // Stop the display. Display thread should call ExitDisplay and the function returns after the thread has terminated
+  void DisplayExit() override = 0;                                                                                           // Stop the display. Display thread should call ExitDisplay and then wait that IsRunning() returns false
+  bool IsRunning() const override { return mDisplayRunning; }
   virtual void SwitchFullscreen(bool set) = 0;                                                                               // Toggle full-screen mode
   virtual void ToggleMaximized(bool set) = 0;                                                                                // Maximize window
   virtual void SetVSync(bool enable) = 0;                                                                                    // Enable / disable vsync
@@ -63,10 +65,8 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
 
   int32_t getDisplayControl() const override { return mDisplayControl; }
   int32_t getSendKey() const override { return mSendKey; }
-  int32_t getNeedUpdate() const override { return mNeedUpdate; }
   void setDisplayControl(int32_t v) override { mDisplayControl = v; }
   void setSendKey(int32_t v) override { mSendKey = v; }
-  void setNeedUpdate(int32_t v) override { mNeedUpdate = v; }
 
   frontendTypes frontendType() const { return mFrontendType; }
   const char* frontendName() const override { return mFrontendName; }
@@ -83,6 +83,7 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
  protected:
   virtual int32_t FrontendMain() = 0;
   static void* FrontendThreadWrapper(void*);
+  void waitForFPSLimit(); // Sleep until the next frame is due according to fpsRate (no sleep with maxFPSRate or fpsRate <= 0)
 
   static constexpr int32_t INIT_WIDTH = 1024, INIT_HEIGHT = 768;                        // Initial window size, before maximizing
   static constexpr const char* DISPLAY_WINDOW_NAME = "GPU CA Standalone Event Display"; // Title of event display set by backend
@@ -129,13 +130,14 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
   int32_t mDisplayWidth = INIT_WIDTH;
   int32_t mCanDrawText = 0; // 1 = in compat mode, 2 = with shader
 
-  int32_t mMaxFPSRate = 0; // run at highest possible frame rate, do not sleep in between frames
+  std::chrono::steady_clock::time_point mNextFrameTime;
 
   GPUDisplay* mDisplay = nullptr;        // Ptr to display, not owning, set by display when it connects to backend
   GPUDisplayBackend* mBackend = nullptr; // Ptr to backend, not owning
 
   frontendTypes mFrontendType = TYPE_INVALID;
   const char* mFrontendName = nullptr;
+  volatile bool mDisplayRunning = false;
 
   std::unique_ptr<GPUDisplayGUIWrapper> mGUI;
 

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx

@@ -282,7 +282,7 @@ int32_t GPUDisplayFrontendGlfw::FrontendMain()
   }
 
   pthread_mutex_lock(&mSemLockExit);
-  mGlfwRunning = true;
+  mDisplayRunning = true;
   pthread_mutex_unlock(&mSemLockExit);
 
   if (mBackend->ExtInit()) {
@@ -304,6 +304,7 @@ int32_t GPUDisplayFrontendGlfw::FrontendMain()
     if (backend()->backendType() == GPUDisplayBackend::TYPE_OPENGL) {
       glfwSwapBuffers(mWindow);
     }
+    waitForFPSLimit();
     glfwPollEvents();
   }
 
@@ -312,7 +313,7 @@ int32_t GPUDisplayFrontendGlfw::FrontendMain()
   pthread_mutex_lock(&mSemLockExit);
   glfwDestroyWindow(mWindow);
   glfwTerminate();
-  mGlfwRunning = false;
+  mDisplayRunning = false;
   pthread_mutex_unlock(&mSemLockExit);
 
   return 0;
@@ -321,13 +322,10 @@ int32_t GPUDisplayFrontendGlfw::FrontendMain()
 void GPUDisplayFrontendGlfw::DisplayExit()
 {
   pthread_mutex_lock(&mSemLockExit);
-  if (mGlfwRunning) {
+  if (mDisplayRunning) {
     glfwSetWindowShouldClose(mWindow, true);
   }
   pthread_mutex_unlock(&mSemLockExit);
-  while (mGlfwRunning) {
-    usleep(10000);
-  }
 }
 
 void GPUDisplayFrontendGlfw::OpenGLPrint(const char* s, float x, float y, float r, float g, float b, float a, bool fromBotton)

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.h

@@ -54,7 +54,6 @@ class GPUDisplayFrontendGlfw : public GPUDisplayFrontend
 
   GLFWwindow* mWindow;
 
-  volatile bool mGlfwRunning = false;
   pthread_mutex_t mSemLockExit = PTHREAD_MUTEX_INITIALIZER;
   int32_t mWindowX = 0;
   int32_t mWindowY = 0;

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlut.cxx

@@ -32,10 +32,11 @@ GPUDisplayFrontendGlut::GPUDisplayFrontendGlut()
   mFrontendName = "GLUT";
 }
 
-void GPUDisplayFrontendGlut::displayFunc()
+void GPUDisplayFrontendGlut::displayFunc() // TODO: Functions should be lambdas, to get rid of the static me variable!
 {
   me->DrawGLScene();
   glutSwapBuffers();
+  me->waitForFPSLimit();
 }
 
 void GPUDisplayFrontendGlut::glutLoopFunc()
@@ -261,12 +262,12 @@ int32_t GPUDisplayFrontendGlut::FrontendMain()
   ToggleMaximized(true);
 
   pthread_mutex_lock(&mSemLockExit);
-  mGlutRunning = true;
+  mDisplayRunning = true;
   pthread_mutex_unlock(&mSemLockExit);
   glutMainLoop();
   mDisplayControl = 2;
   pthread_mutex_lock(&mSemLockExit);
-  mGlutRunning = false;
+  mDisplayRunning = false;
   pthread_mutex_unlock(&mSemLockExit);
 
   ExitDisplay();
@@ -276,13 +277,10 @@ int32_t GPUDisplayFrontendGlut::FrontendMain()
 void GPUDisplayFrontendGlut::DisplayExit()
 {
   pthread_mutex_lock(&mSemLockExit);
-  if (mGlutRunning) {
+  if (mDisplayRunning) {
     glutLeaveMainLoop();
   }
   pthread_mutex_unlock(&mSemLockExit);
-  while (mGlutRunning) {
-    usleep(10000);
-  }
 }
 
 void GPUDisplayFrontendGlut::OpenGLPrint(const char* s, float x, float y, float r, float g, float b, float a, bool fromBotton)

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlut.h

@@ -48,7 +48,6 @@ class GPUDisplayFrontendGlut : public GPUDisplayFrontend
   static int32_t GetKey(int32_t key);
   static void GetKey(int32_t keyin, int32_t& keyOut, int32_t& keyPressOut, bool special);
 
-  volatile bool mGlutRunning = false;
   pthread_mutex_t mSemLockExit = PTHREAD_MUTEX_INITIALIZER;
 
   int32_t mWidth = INIT_WIDTH;