ITS: Fix GPU deterministic mode + refactoring

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

Author: Felix Schlepper

Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h

@@ -17,35 +17,36 @@
 #include "ITStracking/Definitions.h"
 #include "ITStracking/TrackerTraits.h"
 #include "ITStrackingGPU/TimeFrameGPU.h"
+#include "Framework/Logger.h"
 
 namespace o2
 {
 namespace its
 {
 
 template <int nLayers = 7>
-class TrackerTraitsGPU : public TrackerTraits
+class TrackerTraitsGPU final : public TrackerTraits
 {
  public:
   TrackerTraitsGPU() = default;
   ~TrackerTraitsGPU() override = default;
 
-  // void computeLayerCells() final;
-  void adoptTimeFrame(TimeFrame* tf) override;
-  void initialiseTimeFrame(const int iteration) override;
-  void computeLayerTracklets(const int iteration, int, int) final;
-  void computeLayerCells(const int iteration) override;
-  void setBz(float) override;
-  void findCellsNeighbours(const int iteration) override;
-  void findRoads(const int iteration) override;
+  void adoptTimeFrame(TimeFrame* tf) final;
+  void initialiseTimeFrame(const int iteration) final;
+  void setBz(float) final;
 
-  // Methods to get CPU execution from traits
-  void initialiseTimeFrameHybrid(const int iteration) override { initialiseTimeFrame(iteration); };
-  void computeTrackletsHybrid(const int iteration, int, int) override;
-  void computeCellsHybrid(const int iteration) override;
-  void findCellsNeighboursHybrid(const int iteration) override;
+  void computeLayerTracklets(const int iteration, int, int) final { LOGP(fatal, "computeLayerTracklers must never be called from Hybrid traits!"); };
+  void computeLayerCells(const int iteration) final { LOGP(fatal, "computeLayerCells must never be called from Hybrid traits!"); };
+  void findCellsNeighbours(const int iteration) final { LOGP(fatal, "findCellsNeighbours must never be called from Hybrid traits!"); };
+  void findRoads(const int iteration) final { LOGP(fatal, "findRoads must never be called from Hybrid traits!"); };
+  void extendTracks(const int iteration) final { LOGP(fatal, "extendTracks must never be called from Hybrid traits!"); };
+  void findShortPrimaries() final { LOGP(fatal, "findShortPrimaries must never be called from Hybrid traits!"); };
 
-  void extendTracks(const int iteration) override;
+  void initialiseTimeFrameHybrid(const int iteration) final { initialiseTimeFrame(iteration); };
+  void computeTrackletsHybrid(const int iteration, int, int) final;
+  void computeCellsHybrid(const int iteration) final;
+  void findCellsNeighboursHybrid(const int iteration) final;
+  void findRoadsHybrid(const int iteration) final;
 
   // TimeFrameGPU information forwarding
   int getTFNumberOfClusters() const override;

Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx

@@ -11,10 +11,7 @@
 ///
 
 #include <array>
-#include <sstream>
-#include <iostream>
 #include <unistd.h>
-#include <thread>
 
 #include "DataFormatsITS/TrackITS.h"
 
@@ -40,26 +37,6 @@ void TrackerTraitsGPU<nLayers>::initialiseTimeFrame(const int iteration)
   mTimeFrameGPU->loadIndexTableUtils(iteration);
 }
 
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int, int)
-{
-}
-
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
-{
-}
-
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
-{
-}
-
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::extendTracks(const int iteration)
-{
-}
-
 template <int nLayers>
 void TrackerTraitsGPU<nLayers>::setBz(float bz)
 {
@@ -260,7 +237,7 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighboursHybrid(const int iteration)
 };
 
 template <int nLayers>
-void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
+void TrackerTraitsGPU<nLayers>::findRoadsHybrid(const int iteration)
 {
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
   for (int startLevel{mTrkParams[iteration].CellsPerRoad()}; startLevel >= mTrkParams[iteration].CellMinimumLevel(); --startLevel) {

Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu

@@ -50,20 +50,17 @@ class TrackerTraits;
 
 class Tracker
 {
+  using LogFunc = std::function<void(const std::string& s)>;
 
  public:
   Tracker(TrackerTraits* traits);
 
-  Tracker(const Tracker&) = delete;
-  Tracker& operator=(const Tracker&) = delete;
-  ~Tracker();
-
   void adoptTimeFrame(TimeFrame& tf);
 
   void clustersToTracks(
-    std::function<void(std::string s)> = [](std::string s) { std::cout << s << std::endl; }, std::function<void(std::string s)> = [](std::string s) { std::cerr << s << std::endl; });
+    LogFunc = [](std::string s) { std::cout << s << std::endl; }, LogFunc = [](std::string s) { std::cerr << s << std::endl; });
   void clustersToTracksHybrid(
-    std::function<void(std::string s)> = [](std::string s) { std::cout << s << std::endl; }, std::function<void(std::string s)> = [](std::string s) { std::cerr << s << std::endl; });
+    LogFunc = [](std::string s) { std::cout << s << std::endl; }, LogFunc = [](std::string s) { std::cerr << s << std::endl; });
   std::vector<TrackITSExt>& getTracks();
 
   void setParameters(const std::vector<TrackingParameters>&);
@@ -74,41 +71,48 @@ class Tracker
   bool isMatLUT() const;
   void setNThreads(int n);
   int getNThreads() const;
-  std::uint32_t mTimeFrameCounter = 0;
+  void printSummary() const;
 
  private:
+  enum TrackerType : uint8_t { CPU = 0,
+                               Hybrid,
+                               NSize };
+  template <TrackerType>
+  void clusterToTracksImpl(LogFunc, LogFunc);
+  static constexpr const char* sTrackerNames[TrackerType::NSize] = {"CPU", "Hybrid"};
+
+  // CPU
   void initialiseTimeFrame(int& iteration);
   void computeTracklets(int& iteration, int& iROFslice, int& iVertex);
   void computeCells(int& iteration);
   void findCellsNeighbours(int& iteration);
   void findRoads(int& iteration);
-
+  void findShortPrimaries();
+  void extendTracks(int& iteration);
+  // Hyrbid
   void initialiseTimeFrameHybrid(int& iteration);
   void computeTrackletsHybrid(int& iteration, int& iROFslice, int& iVertex);
   void computeCellsHybrid(int& iteration);
   void findCellsNeighboursHybrid(int& iteration);
   void findRoadsHybrid(int& iteration);
   void findTracksHybrid(int& iteration);
 
-  void findShortPrimaries();
-  void findTracks();
-  void extendTracks(int& iteration);
-
   // MC interaction
   void computeRoadsMClabels();
   void computeTracksMClabels();
   void rectifyClusterIndices();
 
   template <typename... T>
-  float evaluateTask(void (Tracker::*)(T...), const char*, std::function<void(std::string s)> logger, T&&... args);
+  float evaluateTask(void (Tracker::*)(T...), const char*, LogFunc logger, T&&... args);
 
   TrackerTraits* mTraits = nullptr; /// Observer pointer, not owned by this class
   TimeFrame* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
 
   std::vector<TrackingParameters> mTrkParams;
   o2::gpu::GPUChainITS* mRecoChain = nullptr;
 
-  unsigned int mNumberOfRuns{0};
+  unsigned int mNumberOfDroppedTFs{0};
+  unsigned int mTimeFrameCounter{0};
 };
 
 inline void Tracker::setParameters(const std::vector<TrackingParameters>& trkPars)
@@ -117,8 +121,7 @@ inline void Tracker::setParameters(const std::vector<TrackingParameters>& trkPar
 }
 
 template <typename... T>
-float Tracker::evaluateTask(void (Tracker::*task)(T...), const char* taskName, std::function<void(std::string s)> logger,
-                            T&&... args)
+float Tracker::evaluateTask(void (Tracker::*task)(T...), const char* taskName, LogFunc logger, T&&... args)
 {
   float diff{0.f};
 

Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h

@@ -51,20 +51,21 @@ class TrackerTraits
  public:
   virtual ~TrackerTraits() = default;
   virtual void adoptTimeFrame(TimeFrame* tf);
+
   virtual void initialiseTimeFrame(const int iteration);
   virtual void computeLayerTracklets(const int iteration, int iROFslice, int iVertex);
   virtual void computeLayerCells(const int iteration);
   virtual void findCellsNeighbours(const int iteration);
   virtual void findRoads(const int iteration);
-  virtual void initialiseTimeFrameHybrid(const int iteration) { LOGP(error, "initialiseTimeFrameHybrid: this method should never be called with CPU traits"); }
-  virtual void computeTrackletsHybrid(const int iteration, int, int) { LOGP(error, "computeTrackletsHybrid: this method should never be called with CPU traits"); }
-  virtual void computeCellsHybrid(const int iteration) { LOGP(error, "computeCellsHybrid: this method should never be called with CPU traits"); }
-  virtual void findCellsNeighboursHybrid(const int iteration) { LOGP(error, "findCellsNeighboursHybrid: this method should never be called with CPU traits"); }
-  virtual void findRoadsHybrid(const int iteration) { LOGP(error, "findRoadsHybrid: this method should never be called with CPU traits"); }
-  virtual void findTracksHybrid(const int iteration) { LOGP(error, "findTracksHybrid: this method should never be called with CPU traits"); }
-  virtual void findTracks() { LOGP(error, "findTracks: this method is deprecated."); }
   virtual void extendTracks(const int iteration);
   virtual void findShortPrimaries();
+
+  virtual void initialiseTimeFrameHybrid(const int iteration) { LOGP(fatal, "initialiseTimeFrameHybrid: this method should never be called with CPU traits"); }
+  virtual void computeTrackletsHybrid(const int iteration, int, int) { LOGP(fatal, "computeTrackletsHybrid: this method should never be called with CPU traits"); }
+  virtual void computeCellsHybrid(const int iteration) { LOGP(fatal, "computeCellsHybrid: this method should never be called with CPU traits"); }
+  virtual void findCellsNeighboursHybrid(const int iteration) { LOGP(fatal, "findCellsNeighboursHybrid: this method should never be called with CPU traits"); }
+  virtual void findRoadsHybrid(const int iteration) { LOGP(fatal, "findRoadsHybrid: this method should never be called with CPU traits"); }
+
   virtual void setBz(float bz);
   virtual bool trackFollowing(TrackITSExt* track, int rof, bool outward, const int iteration);
   virtual void processNeighbours(int iLayer, int iLevel, const std::vector<CellSeed>& currentCellSeed, const std::vector<int>& currentCellId, std::vector<CellSeed>& updatedCellSeed, std::vector<int>& updatedCellId);

Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h

@@ -37,9 +37,7 @@ class ITSTrackingInterface
                        const bool overrBeamEst)
     : mIsMC{isMC},
       mUseTriggers{trgType},
-      mOverrideBeamEstimation{overrBeamEst}
-  {
-  }
+      mOverrideBeamEstimation{overrBeamEst} {}
 
   void setClusterDictionary(const o2::itsmft::TopologyDictionary* d) { mDict = d; }
   void setMeanVertex(const o2::dataformats::MeanVertexObject* v)
@@ -56,6 +54,7 @@ class ITSTrackingInterface
   void initialise();
   template <bool isGPU = false>
   void run(framework::ProcessingContext& pc);
+  void printSummary() const;
 
   virtual void updateTimeDependentParams(framework::ProcessingContext& pc);
   virtual void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj);