GPU Display: Cleanup

Author: davidrohr

GPU/GPUTracking/Definitions/GPUSettingsList.h

@@ -422,6 +422,7 @@ AddOption(debugOnFailureMaxSize, uint32_t, 0, "", 0, "Max size of existing dumps
 AddOption(debugOnFailureDirectory, std::string, ".", "", 0, "Target folder for debug / dump")
 AddOption(ROOTDumpFile, std::string, "gpudebug.root", "", 0, "File name for ROOT dump (default gpudebug.root)")
 AddOption(memoryStat, bool, false, "", 0, "Print memory statistics")
+AddVariable(runsStandalone, bool, false)
 AddVariable(eventDisplay, o2::gpu::GPUDisplayFrontendInterface*, nullptr)
 AddSubConfig(GPUSettingsProcessingRTC, rtc)
 AddSubConfig(GPUSettingsProcessingRTCtechnical, rtctech)

GPU/GPUTracking/Global/GPUChainTracking.cxx

@@ -849,24 +849,23 @@ int32_t GPUChainTracking::RunChainFinalize()
 
     mEventDisplay->WaitTillEventShown();
 
-    if (GetProcessingSettings().eventDisplay->EnableSendKey()) {
+    if (GetProcessingSettings().runsStandalone) {
       while (kbhit()) {
         getch();
       }
       GPUInfo("Press key for next event!");
     }
-
     int32_t iKey;
     do {
       usleep(10000);
-      if (GetProcessingSettings().eventDisplay->EnableSendKey()) {
+      if (GetProcessingSettings().runsStandalone) {
         iKey = kbhit() ? getch() : 0;
         if (iKey == 27) {
           GetProcessingSettings().eventDisplay->setDisplayControl(2);
         } else if (iKey == 'n') {
           break;
         } else if (iKey) {
-          GetProcessingSettings().eventDisplay->sendKey(iKey);
+          GetProcessingSettings().eventDisplay->sendExternalGUIKey(iKey);
         }
       }
     } while (GetProcessingSettings().eventDisplay->getDisplayControl() == 0);

GPU/GPUTracking/Standalone/Benchmark/standalone.cxx

@@ -760,6 +760,7 @@ int32_t main(int argc, char** argv)
   if (ReadConfiguration(argc, argv)) {
     return 1;
   }
+  configStandalone.proc.runsStandalone = true;
   eventsDir = std::string(configStandalone.absoluteEventsDir ? "" : "events/") + configStandalone.eventsDir + "/";
 
   GPUSettingsDeviceBackend deviceSet;

GPU/GPUTracking/display/GPUDisplay.h

@@ -60,7 +60,7 @@ class GPUDisplay : public GPUDisplayInterface
 
   void HandleKey(uint8_t key);
   int32_t DrawGLScene();
-  void HandleSendKey(int32_t key);
+  void HandleExternalGUIKey(int32_t key);
   int32_t InitDisplay(bool initFailure = false);
   void ResizeScene(int32_t width, int32_t height, bool init = false);
 

GPU/GPUTracking/display/GPUDisplayInterface.h

@@ -57,10 +57,9 @@ class GPUDisplayFrontendInterface
   virtual ~GPUDisplayFrontendInterface();
   static GPUDisplayFrontendInterface* getFrontend(const char* type);
   virtual void StopDisplay() = 0;
-  virtual bool EnableSendKey() = 0;
   virtual int32_t getDisplayControl() const = 0;
   virtual void setDisplayControl(int32_t v) = 0;
-  virtual void sendKey(int32_t v) = 0;
+  virtual void sendExternalGUIKey(int32_t v) = 0;
   virtual const char* frontendName() const = 0;
 
  protected:

GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx

@@ -85,27 +85,37 @@ void GPUDisplayFrontend::waitForFPSLimit()
     mNextFrameTime = now;
     return;
   }
-  const auto period = std::chrono::duration_cast<std::chrono::steady_clock::duration>(std::chrono::duration<double>(1. / cfg.fpsRate));
+  const auto period = std::chrono::duration_cast<std::chrono::steady_clock::duration>(std::chrono::duration<double>(1. / cfg.fpsRate)); // TODO: wake up on HasExternalGUISignals
   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::HandleSendKeys()
+void GPUDisplayFrontend::HandleExternalGUISignals()
 {
-  std::lock_guard lock(mSendKeyMutex);
-  for (auto key : mSendKeys) {
-    mDisplay->HandleSendKey(key);
+  HandleExternalGUIKeys();
+}
+
+bool GPUDisplayFrontend::HasExternalGUISignals() const
+{
+
+}
+
+void GPUDisplayFrontend::HandleExternalGUIKeys()
+{
+  std::lock_guard lock(mExternalGUIKeyMutex);
+  for (auto key : mExternalGUIKeys) {
+    mDisplay->HandleExternalGUIKey(key);
   }
-  mSendKeys.clear();
+  mExternalGUIKeys.clear();
 }
 
-void GPUDisplayFrontend::sendKey(int32_t v)
+void GPUDisplayFrontend::sendExternalGUIKey(int32_t v)
 {
-  std::lock_guard lock(mSendKeyMutex);
-  mSendKeys.emplace_back(v);
+  std::lock_guard lock(mExternalGUIKeyMutex);
+  mExternalGUIKeys.emplace_back(v);
 }
 
 void GPUDisplayFrontend::HandleKey(uint8_t key) { mDisplay->HandleKey(key); }
@@ -124,7 +134,6 @@ void GPUDisplayFrontend::ExitDisplay()
   stopGUI();
   mGUI.reset(nullptr);
 }
-bool GPUDisplayFrontend::EnableSendKey() { return true; }
 
 void GPUDisplayFrontend::stopGUI()
 {

GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h

@@ -57,7 +57,6 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
   virtual void ToggleMaximized(bool set) = 0;                                                                                // Maximize window
   virtual void SetVSync(bool enable) = 0;                                                                                    // Enable / disable vsync
   virtual bool canSetVSync() { return false; }                                                                               // OpenGL: swap interval can be set
-  bool EnableSendKey() override;                                                                                             // Request external keys (e.g. from terminal)
   virtual void OpenGLPrint(const char* s, float x, float y, float r, float g, float b, float a, bool fromBotton = true) = 0; // Print text on the display (needs the backend to build the font)
   GPUDisplayBackend* backend();
   static GPUDisplayFrontend* getFrontend(const char* type);
@@ -69,7 +68,7 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
 
   int32_t getDisplayControl() const override { return mDisplayControl; }
   void setDisplayControl(int32_t v) override { mDisplayControl = v; }
-  void sendKey(int32_t v) override;
+  void sendExternalGUIKey(int32_t v) override;
 
   frontendTypes frontendType() const { return mFrontendType; }
   const char* frontendName() const override { return mFrontendName; }
@@ -121,8 +120,8 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
   // volatile variables to exchange control informations between display and backend
   volatile int32_t mDisplayControl = 0; // Control for next event (=1) or quit (=2)
   volatile int32_t mNeedUpdate = 0;     // flag that backend shall update the GL window, and call DrawGLScene
-  std::mutex mSendKeyMutex;
-  std::vector<int32_t> mSendKeys; // Keys sent by external entity (usually console), may be ignored by backend.
+  std::mutex mExternalGUIKeyMutex;
+  std::vector<int32_t> mExternalGUIKeys; // Keys sent by external entity (usually console), may be ignored by backend.
   std::mutex mExitStateMutex;
 
   // Keyboard / Mouse actions
@@ -151,7 +150,8 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
 
   void HandleKey(uint8_t key);                     // Callback for handling key presses
   int32_t DrawGLScene();                           // Callback to draw the GL scene
-  void HandleSendKeys();                           // Optional callback to handle key press from external source (e.g. stdin by default)
+  void HandleExternalGUISignals();                 // Callback to handle signals from external GUIs
+  bool HasExternalGUISignals() const;              // Returns whether there are currently pending signals from external GUIs to be handled
   void ResizeScene(int32_t width, int32_t height); // Callback when GL window is resized
   int32_t InitDisplay(bool initFailure = false);   // Callback to initialize the GL Display (to be called in StartDisplay)
   void ExitDisplay();                              // Callback to clean up the GL Display
@@ -160,6 +160,8 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
   void setWindowState(bool fullScreen, bool maximized); // Sync the settings if the window manager changed the window state
   void focusLost();                                     // Release all keys and mouse buttons when the window loses focus, since the release events go to another window
   void applyInitialWindowState();                       // Switch to fullscreen / maximize at startup according to the settings
+ private:
+  void HandleExternalGUIKeys();
 };
 } // namespace o2::gpu
 

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx

@@ -326,7 +326,7 @@ int32_t GPUDisplayFrontendGlfw::FrontendMain()
 
   int32_t retVal = 0;
   while (!glfwWindowShouldClose(mWindow)) {
-    HandleSendKeys();
+    HandleExternalGUISignals();
     if (DrawGLScene()) {
       fprintf(stderr, "Error drawing GL scene\n");
       retVal = 1;
@@ -398,11 +398,6 @@ void GPUDisplayFrontendGlfw::SetVSync(bool enable)
 
 bool GPUDisplayFrontendGlfw::canSetVSync() { return backend()->backendType() == GPUDisplayBackend::TYPE_OPENGL; }
 
-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

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.h

@@ -32,7 +32,6 @@ class GPUDisplayFrontendGlfw : public GPUDisplayFrontend
   void ToggleMaximized(bool set) override;
   void SetVSync(bool enable) override;
   void OpenGLPrint(const char* s, float x, float y, float r, float g, float b, float a, bool fromBotton = true) override;
-  bool EnableSendKey() override;
   void getSize(int32_t& width, int32_t& height) override;
   float getDisplayScale() const override { return mScale; }
   float getRefreshRate() override;

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlut.cxx

@@ -45,7 +45,7 @@ void GPUDisplayFrontendGlut::displayFunc() // TODO: Functions should be lambdas,
 
 void GPUDisplayFrontendGlut::glutLoopFunc()
 {
-  me->HandleSendKeys();
+  me->HandleExternalGUISignals();
   displayFunc();
 }