ITS: drop hybrid functions use dynamic dispatch

Author: Felix Schlepper

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

@@ -13,11 +13,8 @@
 #ifndef ITSTRACKINGGPU_TRACKERTRAITSGPU_H_
 #define ITSTRACKINGGPU_TRACKERTRAITSGPU_H_
 
-#include "ITStracking/Configuration.h"
-#include "ITStracking/Definitions.h"
 #include "ITStracking/TrackerTraits.h"
 #include "ITStrackingGPU/TimeFrameGPU.h"
-#include "Framework/Logger.h"
 
 namespace o2
 {
@@ -33,20 +30,19 @@ class TrackerTraitsGPU final : public TrackerTraits
 
   void adoptTimeFrame(TimeFrame* tf) final;
   void initialiseTimeFrame(const int iteration) final;
-  void setBz(float) final;
 
-  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 computeLayerTracklets(const int iteration, int, int) final;
+  void computeLayerCells(const int iteration) final;
+  void findCellsNeighbours(const int iteration) final;
+  void findRoads(const int iteration) final;
+
+  bool supportsExtendTracks() const noexcept final { return false; }
+  bool supportsFindShortPrimaries() const noexcept final { return false; }
+
+  void setBz(float) final;
 
-  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;
+  const char* getName() const noexcept final { return "GPU"; }
+  bool isGPU() const noexcept final { return true; }
 
   // TimeFrameGPU information forwarding
   int getTFNumberOfClusters() const override;

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

@@ -38,34 +38,7 @@ void TrackerTraitsGPU<nLayers>::initialiseTimeFrame(const int iteration)
 }
 
 template <int nLayers>
-void TrackerTraitsGPU<nLayers>::setBz(float bz)
-{
-  mBz = bz;
-  mTimeFrameGPU->setBz(bz);
-}
-
-template <int nLayers>
-int TrackerTraitsGPU<nLayers>::getTFNumberOfClusters() const
-{
-  return mTimeFrameGPU->getNumberOfClusters();
-}
-
-template <int nLayers>
-int TrackerTraitsGPU<nLayers>::getTFNumberOfTracklets() const
-{
-  return std::accumulate(mTimeFrameGPU->getNTracklets().begin(), mTimeFrameGPU->getNTracklets().end(), 0);
-}
-
-template <int nLayers>
-int TrackerTraitsGPU<nLayers>::getTFNumberOfCells() const
-{
-  return mTimeFrameGPU->getNumberOfCells();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Hybrid tracking
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::computeTrackletsHybrid(const int iteration, int iROFslice, int iVertex)
+void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
 {
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
   mTimeFrameGPU->createTrackletsLUTDevice(iteration);
@@ -138,7 +111,7 @@ void TrackerTraitsGPU<nLayers>::computeTrackletsHybrid(const int iteration, int
 }
 
 template <int nLayers>
-void TrackerTraitsGPU<nLayers>::computeCellsHybrid(const int iteration)
+void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
 {
   mTimeFrameGPU->createCellsLUTDevice();
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
@@ -185,7 +158,7 @@ void TrackerTraitsGPU<nLayers>::computeCellsHybrid(const int iteration)
 }
 
 template <int nLayers>
-void TrackerTraitsGPU<nLayers>::findCellsNeighboursHybrid(const int iteration)
+void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
 {
   mTimeFrameGPU->createNeighboursIndexTablesDevice();
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
@@ -237,7 +210,7 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighboursHybrid(const int iteration)
 };
 
 template <int nLayers>
-void TrackerTraitsGPU<nLayers>::findRoadsHybrid(const int iteration)
+void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
 {
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
   for (int startLevel{mTrkParams[iteration].CellsPerRoad()}; startLevel >= mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
@@ -343,5 +316,30 @@ void TrackerTraitsGPU<nLayers>::findRoadsHybrid(const int iteration)
   }
 };
 
+template <int nLayers>
+int TrackerTraitsGPU<nLayers>::getTFNumberOfClusters() const
+{
+  return mTimeFrameGPU->getNumberOfClusters();
+}
+
+template <int nLayers>
+int TrackerTraitsGPU<nLayers>::getTFNumberOfTracklets() const
+{
+  return std::accumulate(mTimeFrameGPU->getNTracklets().begin(), mTimeFrameGPU->getNTracklets().end(), 0);
+}
+
+template <int nLayers>
+int TrackerTraitsGPU<nLayers>::getTFNumberOfCells() const
+{
+  return mTimeFrameGPU->getNumberOfCells();
+}
+
+template <int nLayers>
+void TrackerTraitsGPU<nLayers>::setBz(float bz)
+{
+  mBz = bz;
+  mTimeFrameGPU->setBz(bz);
+}
+
 template class TrackerTraitsGPU<7>;
 } // namespace o2::its

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

@@ -57,11 +57,7 @@ class Tracker
 
   void adoptTimeFrame(TimeFrame& tf);
 
-  void clustersToTracks(
-    LogFunc = [](std::string s) { std::cout << s << std::endl; }, LogFunc = [](std::string s) { std::cerr << s << std::endl; });
-  void clustersToTracksHybrid(
-    LogFunc = [](std::string s) { std::cout << s << std::endl; }, LogFunc = [](std::string s) { std::cerr << s << std::endl; });
-  std::vector<TrackITSExt>& getTracks();
+  void clustersToTracks(LogFunc = [](std::string s) { std::cout << s << std::endl; }, LogFunc = [](std::string s) { std::cerr << s << std::endl; });
 
   void setParameters(const std::vector<TrackingParameters>&);
   std::vector<TrackingParameters>& getParameters() { return mTrkParams; }
@@ -74,28 +70,13 @@ class Tracker
   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);
 
   // MC interaction
   void computeRoadsMClabels();

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

@@ -16,23 +16,12 @@
 #ifndef TRACKINGITSU_INCLUDE_TRACKERTRAITS_H_
 #define TRACKINGITSU_INCLUDE_TRACKERTRAITS_H_
 
-#include <array>
-#include <chrono>
 #include <cmath>
-#include <fstream>
-#include <iomanip>
-#include <iosfwd>
-#include <memory>
-#include <utility>
-#include <functional>
 
 #include "DetectorsBase/Propagator.h"
-#include "DetectorsBase/MatLayerCylSet.h"
 #include "ITStracking/Configuration.h"
-#include "ITStracking/Definitions.h"
 #include "ITStracking/MathUtils.h"
 #include "ITStracking/TimeFrame.h"
-#include "ITStracking/Road.h"
 
 // #define OPTIMISATION_OUTPUT
 
@@ -51,32 +40,30 @@ 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 bool supportsExtendTracks() const noexcept { return true; }
   virtual void extendTracks(const int iteration);
+  virtual bool supportsFindShortPrimaries() const noexcept { return true; }
   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);
 
   void UpdateTrackingParameters(const std::vector<TrackingParameters>& trkPars);
   TimeFrame* getTimeFrame() { return mTimeFrame; }
 
-  void setIsGPU(const unsigned char isgpu) { mIsGPU = isgpu; };
+  virtual void setBz(float bz);
   float getBz() const;
   void setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType type) { mCorrType = type; }
   bool isMatLUT() const;
+  virtual const char* getName() const noexcept { return "CPU"; }
+  virtual bool isGPU() const noexcept { return false; }
 
   // Others
   GPUhd() static consteval int4 getEmptyBinsRect() { return int4{0, 0, 0, 0}; }
@@ -110,13 +97,11 @@ class TrackerTraits
   o2::gpu::GPUChainITS* mChain = nullptr;
   TimeFrame* mTimeFrame;
   std::vector<TrackingParameters> mTrkParams;
-  bool mIsGPU = false;
 };
 
 inline void TrackerTraits::initialiseTimeFrame(const int iteration)
 {
   mTimeFrame->initialise(iteration, mTrkParams[iteration], mTrkParams[iteration].NLayers);
-  setIsGPU(false);
 }
 
 inline float TrackerTraits::getBz() const