GPU Display Console: Add plenty of useful commands

Author: davidrohr

GPU/GPUTracking/Definitions/GPUSettingsListDisplay.h

@@ -122,6 +122,7 @@ AddOption(consoleVertical, float, 0.5f, "", 0, "Fraction of the window height co
 AddOption(consoleHistorySize, uint32_t, 1000000, "", 0, "Number of console lines kept, the history is shortened to this when it reaches twice the size")
 AddOption(setInfoTime, float, 5.0f, "", 0, "Time in seconds an info message (SetInfo) is shown fully opaque")
 AddOption(setInfoTransition, float, 1.0f, "", 0, "Time in seconds an info message fades out after setInfoTime")
+AddOption(consolePrintToTerminal, bool, false, "", 0, "Also write the replies of console commands to the terminal")
 AddHelp("help", 'h')
 EndConfig()
 

GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx

@@ -191,7 +191,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
     uint32_t nOutCl2 = 0;
     float t1 = 0, t2 = 0;
     int32_t sector1 = 0, sector2 = 0;
-    const o2::tpc::ClusterNativeAccess* GPUrestrict() clusters = merger.GetConstantMem() -> ioPtrs.clustersNative;
+    const o2::tpc::ClusterNativeAccess* GPUrestrict() clusters = merger.GetConstantMem()->ioPtrs.clustersNative;
     for (uint32_t j = 0; j < track.NClusters(); j++) {
       if ((trackClusters[track.FirstClusterRef() + j].state & flagsReject)) {
         continue;
@@ -284,7 +284,7 @@ template <>
 GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::mc>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
 {
 #ifndef GPUCA_GPUCODE
-  const o2::tpc::ClusterNativeAccess* GPUrestrict() clusters = merger.GetConstantMem() -> ioPtrs.clustersNative;
+  const o2::tpc::ClusterNativeAccess* GPUrestrict() clusters = merger.GetConstantMem()->ioPtrs.clustersNative;
   if (clusters == nullptr || clusters->clustersMCTruth == nullptr) {
     return;
   }

GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx

@@ -495,7 +495,7 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToXAlpha(GPUTPCGMMerger* merger, float
 
 GPUd() void GPUTPCGMSectorTrack::CopyBaseTrackCov()
 {
-  const float* GPUrestrict() cov = mOrigTrack -> Param().mC;
+  const float* GPUrestrict() cov = mOrigTrack->Param().mC;
   mParam.mC0 = cov[0];
   mParam.mC2 = cov[2];
   mParam.mC3 = cov[3];

GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx

@@ -52,7 +52,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
   constexpr float kDeg2Rad = M_PI / 180.f;
   CADEBUG(static constexpr float kSectAngle = 2 * M_PI / 18.f);
 
-  const GPUParam& GPUrestrict() param = merger -> Param();
+  const GPUParam& GPUrestrict() param = merger->Param();
 
   GPUdEdx dEdx, dEdxAlt;
   GPUTPCGMPropagator prop;
@@ -126,7 +126,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       const float clAlpha = param.Alpha(clusters[ihit].sector);
       float xx, yy, zz;
       {
-        const ClusterNative& GPUrestrict() cl = merger -> GetConstantMem()->ioPtrs.clustersNative->clustersLinear[clusters[ihit].num];
+        const ClusterNative& GPUrestrict() cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[clusters[ihit].num];
         merger->GetConstantMem()->calibObjects.fastTransform->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), xx, yy, zz, mTOffset);
       }
       // clang-format off
@@ -440,7 +440,7 @@ GPUd() int32_t GPUTPCGMTrackParam::MergeDoubleRowClusters(int32_t& ihit, int32_t
     xx = yy = zz = 0.f;
     clusterState = 0;
     while (true) {
-      const ClusterNative& GPUrestrict() cl = merger -> GetConstantMem()->ioPtrs.clustersNative->clustersLinear[clusters[ihit].num];
+      const ClusterNative& GPUrestrict() cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[clusters[ihit].num];
       float clamp = cl.getQtot();
       float clx, cly, clz;
       merger->GetConstantMem()->calibObjects.fastTransform->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), clx, cly, clz, mTOffset);
@@ -493,7 +493,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
   if (param.rec.tpc.disableRefitAttachment & 1) {
     return -1e6f;
   }
-  const GPUTPCTracker& GPUrestrict() tracker = *(Merger -> GetConstantMem()->tpcTrackers + sector);
+  const GPUTPCTracker& GPUrestrict() tracker = *(Merger->GetConstantMem()->tpcTrackers + sector);
   const GPUTPCRow& GPUrestrict() row = tracker.Row(iRow);
   GPUglobalref() const cahit2* hits = tracker.HitData(row);
   GPUglobalref() const calink* firsthit = tracker.FirstHitInBin(row);
@@ -803,7 +803,7 @@ GPUd() float GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMergedTrackHit* clusters,
   if (N == 0) {
     N = 1;
   }
-  const auto& GPUrestrict() cls = merger -> GetConstantMem()->ioPtrs.clustersNative->clustersLinear;
+  const auto& GPUrestrict() cls = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear;
   float z0 = cls[clusters[0].num].getTime(), zn = cls[clusters[N - 1].num].getTime();
   const auto tmp = zn > z0 ? std::array<float, 3>{zn, z0, GPUTPCGeometry::Row2X(clusters[N - 1].row)} : std::array<float, 3>{z0, zn, GPUTPCGeometry::Row2X(clusters[0].row)};
   return ShiftZ(merger, clusters[0].sector, tmp[0], tmp[1], tmp[2]);

GPU/GPUTracking/display/GPUDisplay.cxx

@@ -245,6 +245,7 @@ int32_t GPUDisplay::DrawGLScene(bool suspended)
       mLoadAndShowEvent = false;
     }
     mCVLoadAndShowEvent.notify_one();
+    mNEventsShown++;
   }
   mSemLockDisplay.Unlock();
 
@@ -376,15 +377,7 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(bool suspended, float animateTim
     } else {
       nextViewMatrix = nextViewMatrix * HMM_Translate({{moveX, moveY * mYFactor, moveZ}});
       if (!rotateModel) {
-        if (rotYaw != 0.f) {
-          nextViewMatrix = nextViewMatrix * HMM_Rotate(rotYaw, {{0, 1, 0}});
-        }
-        if (rotPitch != 0.f) {
-          nextViewMatrix = nextViewMatrix * HMM_Rotate(rotPitch * mYFactor, {{1, 0, 0}});
-        }
-        if (!yUp && rotRoll != 0.f) {
-          nextViewMatrix = nextViewMatrix * HMM_Rotate(rotRoll * mYFactor, {{0, 0, 1}});
-        }
+        nextViewMatrix = nextViewMatrix * cameraRotation({rotYaw, rotPitch, yUp ? 0.f : rotRoll}); // Keyboard and mouse, as rotateCamera
       }
       nextViewMatrix = nextViewMatrix * *mViewMatrix; // Apply previous translation / rotation
       if (yUp) {

GPU/GPUTracking/display/GPUDisplay.h

@@ -62,9 +62,9 @@ class GPUDisplay : public GPUDisplayInterface
   void UpdateCalib(const GPUCalibObjectsConst* calib) override { mCalib = calib; }
   void UpdateParam(const GPUParam* param) override { mParam = param; }
 
-  void HandleKey(uint8_t key, bool external = false); // external: from the Qt GUI or the console, not typed into the event display console
+  void HandleKey(uint8_t key, bool external = false, bool bypassConsole = false); // external: from the Qt GUI or the console, not typed into the event display console; bypassConsole: handled as key also while the console is shown (injectKey)
   int32_t DrawGLScene(bool suspended = false);
-  void HandleExternalGUIKey(int32_t key);
+  void HandleExternalGUIKey(int32_t key, bool bypassConsole = false); // key >= 256: special key with SHIFT
   int32_t InitDisplay(bool initFailure = false);
   void ResizeScene(int32_t width, int32_t height, bool init = false);
   void checkAndApplyConfigChanges(); // Set update flags / apply the settings that changed compared to mOldCfg
@@ -194,6 +194,11 @@ class GPUDisplay : public GPUDisplayInterface
   void takeScreenshot();
   void runAnimation(); // Starts the animation if it has enough points
   void setAnimationPoint();
+  void setCamera(const float (&xyz)[3], const float (&angles)[3]);         // Position and angles (radians, as mAngle: pitch, yaw, roll)
+  void addAnimationPoint(const float (&xyz)[3], const float (&angles)[3]); // Animation point for this camera, the current camera is kept
+  bool lookAt(const float (&target)[3]);                                   // Turn the camera to the point, false if it is the camera position
+  void rotateCamera(const float (&angles)[3]);                             // Yaw, pitch, roll in degrees relative to the view, as the keyboard
+  hmm_mat4 cameraRotation(const float (&angles)[3]) const;                 // Rotation of rotateCamera, applied to the view matrix also for keyboard / mouse
   void resetAnimation();
   void removeAnimationPoint();
   void startAnimation();
@@ -310,6 +315,7 @@ class GPUDisplay : public GPUDisplayInterface
   volatile bool mUpdateDrawCommands = true;
   volatile bool mUpdateRenderPipeline = false;
   volatile bool mLoadAndShowEvent = false;
+  uint32_t mNEventsShown = 0; // Events loaded and drawn, in the frontend thread
   bool mTracksArePropagated = false;
 
   int32_t mAnimate = 0;

GPU/GPUTracking/display/frontend/GPUDisplayConsole.cxx

@@ -13,6 +13,7 @@
 /// \author David Rohr
 
 #include "GPUDisplayConsole.h"
+#include "GPULogging.h"
 #include <algorithm>
 #include <charconv>
 #include <stdexcept>
@@ -85,12 +86,17 @@ void GPUDisplayConsole::handleConsoleKey(uint8_t key)
 
 void GPUDisplayConsole::consolePrint(const char* format, ...)
 {
-  char buffer[1024];
-  va_list args;
+  va_list args, argsCopy;
   va_start(args, format);
-  vsnprintf(buffer, sizeof(buffer), format, args);
+  va_copy(argsCopy, args);
+  std::string buffer(std::max(0, vsnprintf(nullptr, 0, format, args)), '\0');
   va_end(args);
-  consoleAppend(std::string("  ") + buffer); // Indented: output, not a command, skipped by up / down
+  vsnprintf(buffer.data(), buffer.size() + 1, format, argsCopy);
+  va_end(argsCopy);
+  consoleAppend("  " + buffer); // Indented: output, not a command, skipped by up / down
+  if (mPrintToTerminal) {
+    GPUInfo("%s", buffer.c_str());
+  }
 }
 
 void GPUDisplayConsole::consoleInfo(const char* format, const char* text)
@@ -180,16 +186,15 @@ std::tuple<const GPUDisplayConsole::GPUDisplayConsoleCommand&, std::vector<GPUDi
   if (nArgs < nFixed || (!more && nArgs > nFixed)) {
     throw std::runtime_error(name + ": " + std::to_string(nFixed) + (more ? " or more" : "") + " arguments expected, got " + std::to_string(nArgs));
   }
-  auto autoType = [](const std::string& text, bool plain) -> consoleArg { // int64_t for [+-]digits, double for [+-]digits with one '.', string otherwise or if plain text
+  auto autoType = [](const std::string& text, bool plain) -> consoleArg { // int64_t for [+-]digits, double for other decimal numbers (also with exponent, as saveSettings writes them), string otherwise or if plain text
     const char *begin = text.c_str() + (text[0] == '+' || text[0] == '-'), *end = text.c_str() + text.size();
-    const size_t nDigits = std::count_if(begin, end, [](char c) { return c >= '0' && c <= '9'; });
-    const size_t nDots = std::count(begin, end, '.');
-    const bool number = !plain && nDigits && nDigits + nDots == (size_t)(end - begin);
+    const bool number = !plain && begin < end && ((*begin >= '0' && *begin <= '9') || *begin == '.') && std::all_of(begin, end, [](char c) { return (c >= '0' && c <= '9') || c == '.' || c == 'e' || c == 'E' || c == '+' || c == '-'; });
     int64_t intValue = 0;
-    if (number && nDots == 0 && std::from_chars(begin, end, intValue).ec == std::errc()) {
+    double doubleValue = 0.;
+    if (const auto rInt = std::from_chars(begin, end, intValue); number && rInt.ec == std::errc() && rInt.ptr == end) {
       return text[0] == '-' ? -intValue : intValue;
-    } else if (number && nDots <= 1) {
-      return std::stod(text); // Also integers out of the int64_t range
+    } else if (const auto rDouble = std::from_chars(begin, end, doubleValue); number && rDouble.ec == std::errc() && rDouble.ptr == end) {
+      return text[0] == '-' ? -doubleValue : doubleValue; // Also integers out of the int64_t range
     }
     return text;
   };
@@ -206,7 +211,7 @@ std::tuple<const GPUDisplayConsole::GPUDisplayConsoleCommand&, std::vector<GPUDi
       } else if (!std::holds_alternative<double>(value)) {
         throw std::runtime_error(name + ": argument " + std::to_string(i + 1) + " (" + text + ") must be a number");
       }
-    } else if (type != 's' && type != 'i' && type != '+') {
+    } else if (type != 's' && type != 'i' && type != 'a' && type != '+') {
       throw std::runtime_error(name + ": invalid argument types " + types);
     }
     args.emplace_back(std::move(value));
@@ -229,7 +234,11 @@ void GPUDisplayConsole::handleConsoleCommand(std::string_view cmd)
     consolePrint("Invalid command: %s", e.what());
     return;
   }
-  command->func(args);
+  try { // A failing command must not end the display
+    command->func(args);
+  } catch (const std::exception& e) {
+    consolePrint("Error in command %.*s: %s", (int32_t)cmd.size(), cmd.data(), e.what());
+  }
 }
 
 void GPUDisplayConsole::runScript(std::string_view script)
@@ -238,13 +247,44 @@ void GPUDisplayConsole::runScript(std::string_view script)
     consolePrint("Scripts nested too deeply");
     return;
   }
-  mScriptDepth++;
+  std::vector<ScriptLine> lines;
   for (size_t pos = 0; pos < script.size();) {
     const size_t end = std::min(script.find_first_of("\r\n", pos), script.size());
-    handleConsoleCommand(script.substr(pos, end - pos)); // Empty lines (consecutive \r / \n) are ignored
+    if (end > pos) { // Empty lines (consecutive \r / \n) are ignored
+      lines.push_back({std::string(script.substr(pos, end - pos)), mScriptDepth + 1});
+    }
     pos = end + 1;
   }
-  mScriptDepth--;
+  mScriptQueue.insert(mScriptQueue.begin(), lines.begin(), lines.end()); // Before the remaining lines of a script running this one
+  processScripts(false);
+}
+
+void GPUDisplayConsole::processScripts(bool newFrame)
+{
+  if (newFrame) {
+    mWaitFrames -= mWaitFrames > 0;
+    if (mBenchmarkLeft && --mBenchmarkLeft == 0) {
+      const double time = std::chrono::duration<double>(std::chrono::steady_clock::now() - mBenchmarkStart).count();
+      consolePrint("benchmark: %u frames in %.3f s, %.2f fps, %.3f ms per frame", mBenchmarkFrames, time, mBenchmarkFrames / time, time * 1000. / mBenchmarkFrames);
+    }
+  }
+  if (mWaitCondition && mWaitCondition()) {
+    mWaitCondition = nullptr;
+  }
+  const uint32_t outerDepth = mScriptDepth;
+  for (uint32_t n = 0; n < 100000 && mScriptQueue.size() && !mWaitFrames && !mBenchmarkLeft && !mWaitCondition && std::chrono::steady_clock::now() >= mWaitUntil; n++) { // Limit per call: a script must not block the display
+    ScriptLine line = std::move(mScriptQueue.front());
+    mScriptQueue.pop_front();
+    mScriptDepth = line.depth;
+    handleConsoleCommand(line.text);
+  }
+  mScriptDepth = outerDepth;
+}
+
+void GPUDisplayConsole::startBenchmark(uint32_t n)
+{
+  mBenchmarkFrames = mBenchmarkLeft = n;
+  mBenchmarkStart = std::chrono::steady_clock::now();
 }
 
 void GPUDisplayConsole::runScriptFile(const std::string& filename)
@@ -266,7 +306,7 @@ void GPUDisplayConsole::printCommands(const std::function<void(const std::string
     names.emplace_back(name);
   }
   std::sort(names.begin(), names.end());
-  print("Console commands (argument types: s string, i integer, d number, + further arguments):");
+  print("Console commands (argument types: s string, i integer, d number, a any, + further arguments):");
   for (const auto& name : names) {
     const auto& command = mConsoleCommands[name];
     print("  " + name + (command.args.empty() ? "" : " ") + command.args + ": " + command.description);