GPU Display: Block until display started and print meaningful info messages to the console

Author: davidrohr

GPU/GPUTracking/Global/GPUChainTracking.cxx

@@ -824,6 +824,7 @@ int32_t GPUChainTracking::RunChainFinalize()
 
   if (GetProcessingSettings().eventDisplay) {
     if (!mDisplayRunning) {
+      GPUInfo("Starting Event Display...");
       if (mEventDisplay->StartDisplay()) {
         return (1);
       }
@@ -832,6 +833,8 @@ int32_t GPUChainTracking::RunChainFinalize()
       mEventDisplay->ShowNextEvent();
     }
 
+    mEventDisplay->WaitTillEventShown();
+
     if (GetProcessingSettings().eventDisplay->EnableSendKey()) {
       while (kbhit()) {
         getch();
@@ -863,9 +866,9 @@ int32_t GPUChainTracking::RunChainFinalize()
       return (2);
     }
     GetProcessingSettings().eventDisplay->setDisplayControl(0);
-    GPUInfo("Loading next event");
+    GPUInfo("Loading next event...");
 
-    mEventDisplay->WaitForNextEvent();
+    mEventDisplay->BlockTillNextEvent();
   }
 
   return 0;

GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx

@@ -46,7 +46,8 @@ int32_t GPUO2InterfaceDisplay::startDisplay()
   if (retVal) {
     return retVal;
   }
-  mDisplay->WaitForNextEvent();
+  mDisplay->WaitTillEventShown();
+  mDisplay->BlockTillNextEvent();
   return 0;
 }
 
@@ -59,14 +60,15 @@ int32_t GPUO2InterfaceDisplay::show(const GPUTrackingInOutPointers* ptrs)
     ptrs = tmpPtr.get();
   }
   mDisplay->ShowNextEvent(ptrs);
+  mDisplay->WaitTillEventShown();
   do {
     usleep(10000);
   } while (mFrontend->getDisplayControl() == 0);
   if (mFrontend->getDisplayControl() == 2) {
     return 1;
   }
   mFrontend->setDisplayControl(0);
-  mDisplay->WaitForNextEvent();
+  mDisplay->BlockTillNextEvent();
   return 0;
 }
 

GPU/GPUTracking/display/GPUDisplay.cxx

@@ -21,6 +21,8 @@
 #include <memory>
 #include <cstring>
 #include <stdexcept>
+#include <mutex>
+#include <condition_variable>
 
 #ifndef _WIN32
 #include "../utils/linux_helpers.h"
@@ -143,7 +145,7 @@ void GPUDisplay::ResizeScene(int32_t width, int32_t height, bool init)
   mBackend->resizeScene(width, height);
 
   if (init) {
-    mResetScene = 1;
+    mResetScene = true;
     mViewMatrix = MY_HMM_IDENTITY;
     mModelMatrix = MY_HMM_IDENTITY;
   }
@@ -220,6 +222,14 @@ int32_t GPUDisplay::DrawGLScene()
     GPUError("Runtime error %s during display", e.what());
     retVal = 1;
   }
+
+  if (mLoadAndShowEvent) {
+    {
+      std::lock_guard<std::mutex> lock(mMutexLoadAndShowEvent);
+      mLoadAndShowEvent = false;
+    }
+    mCVLoadAndShowEvent.notify_one();
+  }
   mSemLockDisplay.Unlock();
 
   return retVal;
@@ -266,9 +276,9 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(float animateTime, float& mixSla
     mCfgR.camLookOrigin = mCfgR.camYUp = false;
     mAngleRollOrigin = -1e9f;
     mCfgR.fov = 45.f;
-    mUpdateDrawCommands = 1;
+    mUpdateDrawCommands = true;
 
-    mResetScene = 0;
+    mResetScene = false;
   } else {
     float moveZ = scalefactor * ((float)mMouseWheelTmp / 150 + (float)(mFrontend->mKeys[(uint8_t)'W'] - mFrontend->mKeys[(uint8_t)'S']) * (!mFrontend->mKeys[mFrontend->KEY_SHIFT]) * 0.2f * mFPSScale);
     float moveY = scalefactor * ((float)(mFrontend->mKeys[mFrontend->KEY_PAGEDOWN] - mFrontend->mKeys[mFrontend->KEY_PAGEUP]) * 0.2f * mFPSScale);
@@ -386,7 +396,7 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(float animateTime, float& mixSla
     }
     if (deltaLine) {
       SetInfo("%s line width: %f", deltaLine > 0 ? "Increasing" : "Decreasing", mCfgL.lineWidth);
-      mUpdateDrawCommands = 1;
+      mUpdateDrawCommands = true;
     }
     minSize *= 2;
     int32_t deltaPoint = mFrontend->mKeys[(uint8_t)'+'] * (!mFrontend->mKeysShift[(uint8_t)'+']) - mFrontend->mKeys[(uint8_t)'-'] * (!mFrontend->mKeysShift[(uint8_t)'-']);
@@ -396,7 +406,7 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(float animateTime, float& mixSla
     }
     if (deltaPoint) {
       SetInfo("%s point size: %f", deltaPoint > 0 ? "Increasing" : "Decreasing", mCfgL.pointSize);
-      mUpdateDrawCommands = 1;
+      mUpdateDrawCommands = true;
     }
   }
 
@@ -616,7 +626,7 @@ void GPUDisplay::DrawGLScene_internal(float animateTime, bool renderToMixBuffer)
     disableUnsupportedOptions();
   }
   if (mUpdateEventData || mUpdateVertexLists) {
-    mUpdateDrawCommands = 1;
+    mUpdateDrawCommands = true;
   }
 
   if (animateTime < 0 && (mUpdateEventData || mResetScene) && mIOPtrs) {
@@ -625,8 +635,8 @@ void GPUDisplay::DrawGLScene_internal(float animateTime, bool renderToMixBuffer)
     mTimerFPS.ResetStart();
     mFramesDoneFPS = 0;
     mFPSScaleadjust = 0;
-    mUpdateVertexLists = 1;
-    mUpdateEventData = 0;
+    mUpdateVertexLists = true;
+    mUpdateEventData = false;
   }
 
   hmm_mat4 nextViewMatrix = MY_HMM_IDENTITY;
@@ -658,7 +668,7 @@ void GPUDisplay::DrawGLScene_internal(float animateTime, bool renderToMixBuffer)
     mBackend->drawField();
   }
 
-  mUpdateDrawCommands = mUpdateRenderPipeline = 0;
+  mUpdateDrawCommands = mUpdateRenderPipeline = false;
   mBackend->finishDraw(doScreenshot, renderToMixBuffer, mixSlaveImage);
 
   if (animateTime < 0) {
@@ -708,15 +718,25 @@ void GPUDisplay::ShowNextEvent(const GPUTrackingInOutPointers* ptrs)
   if (mMaxClusterZ <= 0) {
     mResetScene = true;
   }
-  mSemLockDisplay.Unlock();
   mFrontend->mNeedUpdate = 1;
   mUpdateEventData = true;
+  mLoadAndShowEvent = true;
+  mSemLockDisplay.Unlock();
 }
 
-void GPUDisplay::WaitForNextEvent() { mSemLockDisplay.Lock(); }
+void GPUDisplay::BlockTillNextEvent() { mSemLockDisplay.Lock(); }
+
+void GPUDisplay::WaitTillEventShown()
+{
+  std::unique_lock<std::mutex> lock(mMutexLoadAndShowEvent);
+  while (mLoadAndShowEvent) {
+    mCVLoadAndShowEvent.wait(lock);
+  }
+}
 
 int32_t GPUDisplay::StartDisplay()
 {
+  mLoadAndShowEvent = true;
   if (mFrontend->StartDisplay()) {
     return (1);
   }

GPU/GPUTracking/display/GPUDisplay.h

@@ -20,13 +20,15 @@
 #include "GPUDisplayInterface.h"
 #include "GPUSettings.h"
 
-#include "../utils/vecpod.h"
-#include "../utils/qsem.h"
-
 #include <array>
+#include <mutex>
+#include <condition_variable>
+
 #include "HandMadeMath.h"
 
 #include "utils/timer.h"
+#include "utils/vecpod.h"
+#include "utils/qsem.h"
 
 namespace o2::gpu
 {
@@ -44,7 +46,8 @@ class GPUDisplay : public GPUDisplayInterface
 
   int32_t StartDisplay() override;
   void ShowNextEvent(const GPUTrackingInOutPointers* ptrs = nullptr) override;
-  void WaitForNextEvent() override;
+  void BlockTillNextEvent() override;
+  void WaitTillEventShown() override;
   void SetCollisionFirstCluster(uint32_t collision, int32_t sector, int32_t cluster) override;
   void UpdateCalib(const GPUCalibObjectsConst* calib) override { mCalib = calib; }
   void UpdateParam(const GPUParam* param) override { mParam = param; }
@@ -221,7 +224,10 @@ class GPUDisplay : public GPUDisplayInterface
   GPUSettingsDisplayRenderer mCfgR;
   const GPUSettingsProcessing& mProcessingSettings;
   GPUQA* mQA;
+
   qSem mSemLockDisplay;
+  std::mutex mMutexLoadAndShowEvent;
+  std::condition_variable mCVLoadAndShowEvent;
 
   bool mDrawTextInCompatMode = false;
   int32_t mDrawTextFontSize = 0;
@@ -272,13 +278,14 @@ class GPUDisplay : public GPUDisplayInterface
   vecpod<int32_t> mTRDTrackIds;
   vecpod<bool> mITSStandaloneTracks;
   std::vector<bool> mTrackFilter;
-  bool mUpdateTrackFilter = false;
 
-  int32_t mUpdateVertexLists = 1;
-  int32_t mUpdateEventData = 0;
-  int32_t mUpdateDrawCommands = 1;
-  int32_t mUpdateRenderPipeline = 0;
-  volatile int32_t mResetScene = 0;
+  volatile bool mUpdateTrackFilter = false;
+  volatile bool mUpdateVertexLists = true;
+  volatile bool mUpdateEventData = false;
+  volatile bool mUpdateDrawCommands = true;
+  volatile bool mUpdateRenderPipeline = false;
+  volatile bool mResetScene = false;
+  volatile bool mLoadAndShowEvent = false;
 
   int32_t mAnimate = 0;
   HighResTimer mAnimationTimer;

GPU/GPUTracking/display/GPUDisplayInterface.h

@@ -40,7 +40,8 @@ class GPUDisplayInterface
   virtual ~GPUDisplayInterface();
   virtual int32_t StartDisplay() = 0;
   virtual void ShowNextEvent(const GPUTrackingInOutPointers* ptrs = nullptr) = 0;
-  virtual void WaitForNextEvent() = 0;
+  virtual void BlockTillNextEvent() = 0;
+  virtual void WaitTillEventShown() = 0;
   virtual void SetCollisionFirstCluster(uint32_t collision, int32_t sector, int32_t cluster) = 0;
   virtual void UpdateCalib(const GPUCalibObjectsConst* calib) = 0;
   virtual void UpdateParam(const GPUParam* param) = 0;

GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx

@@ -89,7 +89,7 @@ void GPUDisplay::HandleKey(uint8_t key)
     mFrontend->mDisplayControl = 2;
     SetInfo("Exiting", 1);
   } else if (key == 'r') {
-    mResetScene = 1;
+    mResetScene = true;
     SetInfo("View reset", 1);
   } else if (key == mFrontend->KEY_ALT && mFrontend->mKeysShift[mFrontend->KEY_ALT]) {
     mCfgR.camLookOrigin ^= 1;

GPU/GPUTracking/display/render/GPUDisplayDraw.cxx

@@ -941,7 +941,7 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
     break; // TODO: Only sector 0 filled for now
   }
 
-  mUpdateVertexLists = 0;
+  mUpdateVertexLists = false;
   size_t totalVertizes = 0;
   for (int32_t i = 0; i < NSECTORS; i++) {
     totalVertizes += mVertexBuffer[i].size();