ITS: apply virtual to vertexer

Author: f3sch

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

@@ -37,27 +37,20 @@ class ROframe;
 
 using constants::its2::InversePhiBinSize;
 
-class VertexerTraitsGPU : public VertexerTraits
+class VertexerTraitsGPU final : public VertexerTraits
 {
  public:
-  VertexerTraitsGPU();
-  ~VertexerTraitsGPU() = default;
-  void initialise(const TrackingParameters&, const int iteration = 0) override;
-  void adoptTimeFrame(TimeFrame*) override;
-  void computeTracklets(const int iteration = 0) override;
-  void computeTrackletMatching(const int iteration = 0) override;
-  void computeVertices(const int iteration = 0) override;
-  void updateVertexingParameters(const std::vector<VertexingParameters>&, const TimeFrameGPUParameters&) override;
-
-  // Hybrid
-  void initialiseHybrid(const TrackingParameters& pars, const int iteration = 0) override { VertexerTraits::initialise(pars, iteration); }
-  void computeTrackletsHybrid(const int iteration = 0) override { VertexerTraits::computeTracklets(iteration); }
-  void computeTrackletMatchingHybrid(const int iteration = 0) override { VertexerTraits::computeTrackletMatching(iteration); }
-  void computeVerticesHybrid(const int iteration = 0) override { VertexerTraits::computeVertices(iteration); }
-  void adoptTimeFrameHybrid(TimeFrame* tf) override { VertexerTraits::adoptTimeFrame(tf); }
-
+  void initialise(const TrackingParameters&, const int iteration = 0) final;
+  void adoptTimeFrame(TimeFrame*) final;
+  void computeTracklets(const int iteration = 0) final;
+  void computeTrackletMatching(const int iteration = 0) final;
+  void computeVertices(const int iteration = 0) final;
+  void updateVertexingParameters(const std::vector<VertexingParameters>&, const TimeFrameGPUParameters&) final;
   void computeVerticesHist();
 
+  virtual bool isGPU() final { return true; }
+  virtual const char* getName() final { return "GPU"; }
+
  protected:
   IndexTableUtils* mDeviceIndexTableUtils;
   gpu::TimeFrameGPU<7>* mTimeFrameGPU;

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

@@ -28,10 +28,6 @@
 
 namespace o2::its
 {
-VertexerTraitsGPU::VertexerTraitsGPU()
-{
-  setIsGPU(true);
-}
 
 void VertexerTraitsGPU::initialise(const TrackingParameters& trackingParams, const int iteration)
 {

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

@@ -52,7 +52,6 @@ class ITSTrackingInterface
   }
   // Task callbacks
   void initialise();
-  template <bool isGPU = false>
   void run(framework::ProcessingContext& pc);
   void printSummary() const;
 

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

@@ -46,6 +46,8 @@ using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
 class Vertexer
 {
+  using LogFunc = std::function<void(const std::string& s)>;
+
  public:
   Vertexer(VertexerTraits* traits);
   virtual ~Vertexer() = default;
@@ -60,43 +62,31 @@ class Vertexer
   std::vector<Vertex> exportVertices();
   VertexerTraits* getTraits() const { return mTraits; };
 
-  float clustersToVertices(std::function<void(std::string s)> = [](std::string s) { std::cout << s << std::endl; });
-  float clustersToVerticesHybrid(std::function<void(std::string s)> = [](std::string s) { std::cout << s << std::endl; });
+  float clustersToVertices(LogFunc = [](const std::string& s) { std::cout << s << '\n'; });
   void filterMCTracklets();
 
   template <typename... T>
   void findTracklets(T&&... args);
-  template <typename... T>
-  void findTrackletsHybrid(T&&... args);
-
   void findTrivialMCTracklets();
   template <typename... T>
   void validateTracklets(T&&... args);
   template <typename... T>
-  void validateTrackletsHybrid(T&&... args);
-  template <typename... T>
   void findVertices(T&&... args);
-  template <typename... T>
-  void findVerticesHybrid(T&&... args);
   void findHistVertices();
 
   template <typename... T>
   void initialiseVertexer(T&&... args);
   template <typename... T>
   void initialiseTimeFrame(T&&... args);
-  template <typename... T>
-  void initialiseVertexerHybrid(T&&... args);
-  template <typename... T>
-  void initialiseTimeFrameHybrid(T&&... args);
 
   // Utils
   void dumpTraits();
   template <typename... T>
-  float evaluateTask(void (Vertexer::*)(T...), const char*, std::function<void(std::string s)> logger, T&&... args);
-  void printEpilog(std::function<void(std::string s)> logger,
-                   bool isHybrid,
-                   const unsigned int trackletN01, const unsigned int trackletN12, const unsigned selectedN, const unsigned int vertexN,
-                   const float initT, const float trackletT, const float selecT, const float vertexT);
+  float evaluateTask(void (Vertexer::*)(T...), const char*, LogFunc logger, T&&... args);
+  void printEpilog(LogFunc& logger,
+                   const unsigned int trackletN01, const unsigned int trackletN12,
+                   const unsigned selectedN, const unsigned int vertexN, const float initT,
+                   const float trackletT, const float selecT, const float vertexT);
 
  private:
   std::uint32_t mTimeFrameCounter = 0;
@@ -147,31 +137,7 @@ inline void Vertexer::findVertices(T&&... args)
 }
 
 template <typename... T>
-void Vertexer::initialiseVertexerHybrid(T&&... args)
-{
-  mTraits->initialiseHybrid(std::forward<T>(args)...);
-}
-
-template <typename... T>
-void Vertexer::findTrackletsHybrid(T&&... args)
-{
-  mTraits->computeTrackletsHybrid(std::forward<T>(args)...);
-}
-
-template <typename... T>
-inline void Vertexer::validateTrackletsHybrid(T&&... args)
-{
-  mTraits->computeTrackletMatchingHybrid(std::forward<T>(args)...);
-}
-
-template <typename... T>
-inline void Vertexer::findVerticesHybrid(T&&... args)
-{
-  mTraits->computeVerticesHybrid(std::forward<T>(args)...);
-}
-
-template <typename... T>
-float Vertexer::evaluateTask(void (Vertexer::*task)(T...), const char* taskName, std::function<void(std::string s)> logger,
+float Vertexer::evaluateTask(void (Vertexer::*task)(T...), const char* taskName, LogFunc logger,
                              T&&... args)
 {
   float diff{0.f};

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

@@ -51,7 +51,7 @@ class VertexerTraits
   VertexerTraits() = default;
   virtual ~VertexerTraits() = default;
 
-  GPUhd() static constexpr int4 getEmptyBinsRect()
+  GPUhdi() static consteval int4 getEmptyBinsRect()
   {
     return int4{0, 0, 0, 0};
   }
@@ -68,12 +68,6 @@ class VertexerTraits
   virtual void computeVertices(const int iteration = 0);
   virtual void adoptTimeFrame(TimeFrame* tf);
   virtual void updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& gpuTfPar);
-  // Hybrid
-  virtual void initialiseHybrid(const TrackingParameters& trackingParams, const int iteration = 0) { initialise(trackingParams, iteration); };
-  virtual void computeTrackletsHybrid(const int iteration = 0) { computeTracklets(iteration); };
-  virtual void computeTrackletMatchingHybrid(const int iteration = 0) { computeTrackletMatching(iteration); };
-  virtual void computeVerticesHybrid(const int iteration = 0) { computeVertices(iteration); };
-  virtual void adoptTimeFrameHybrid(TimeFrame* tf) { adoptTimeFrame(tf); };
 
   void computeVerticesInRof(int,
                             gsl::span<const o2::its::Line>&,
@@ -93,12 +87,12 @@ class VertexerTraits
   // utils
   std::vector<VertexingParameters>& getVertexingParameters() { return mVrtParams; }
   std::vector<VertexingParameters> getVertexingParameters() const { return mVrtParams; }
-  void setIsGPU(const unsigned char isgpu) { mIsGPU = isgpu; };
   void setVertexingParameters(std::vector<VertexingParameters>& vertParams) { mVrtParams = vertParams; }
-  unsigned char getIsGPU() const { return mIsGPU; };
   void dumpVertexerTraits();
   void setNThreads(int n);
   int getNThreads() const { return mNThreads; }
+  virtual bool isGPU() const noexcept { return false; }
+  virtual const char* getName() const noexcept { return "CPU"; }
 
   template <typename T = o2::MCCompLabel>
   static std::pair<T, float> computeMain(const std::vector<T>& elements)
@@ -116,7 +110,6 @@ class VertexerTraits
   }
 
  protected:
-  unsigned char mIsGPU;
   int mNThreads = 1;
 
   std::vector<VertexingParameters> mVrtParams;
@@ -129,7 +122,6 @@ class VertexerTraits
 inline void VertexerTraits::initialise(const TrackingParameters& trackingParams, const int iteration)
 {
   mTimeFrame->initialise(0, trackingParams, 3, (bool)(!iteration)); // iteration for initialisation must be 0 for correctly resetting the frame, we need to pass the non-reset flag for vertices as well, tho.
-  setIsGPU(false);
 }
 
 GPUhdi() const int2 VertexerTraits::getPhiBins(float phi, float dPhi)

Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx

@@ -139,7 +139,6 @@ void ITSTrackingInterface::initialise()
   mVertexer->setParameters(vertParams);
 }
 
-template <bool isGPU>
 void ITSTrackingInterface::run(framework::ProcessingContext& pc)
 {
   auto compClusters = pc.inputs().get<gsl::span<o2::itsmft::CompClusterExt>>("compClusters");
@@ -224,11 +223,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   if (mRunVertexer) {
     vertROFvec.reserve(trackROFvec.size());
     // Run seeding vertexer
-    if constexpr (isGPU) {
-      vertexerElapsedTime = mVertexer->clustersToVerticesHybrid(logger);
-    } else {
-      vertexerElapsedTime = mVertexer->clustersToVertices(logger);
-    }
+    vertexerElapsedTime = mVertexer->clustersToVertices(logger);
   } else { // cosmics
     mTimeFrame->resetRofPV();
   }
@@ -453,8 +448,5 @@ void ITSTrackingInterface::loadROF(gsl::span<itsmft::ROFRecord>& trackROFspan,
 {
   mTimeFrame->loadROFrameData(trackROFspan, clusters, pattIt, mDict, mcLabels);
 }
-
-template void ITSTrackingInterface::run<true>(framework::ProcessingContext& pc);
-template void ITSTrackingInterface::run<false>(framework::ProcessingContext& pc);
 } // namespace its
 } // namespace o2

Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx

@@ -21,76 +21,40 @@
 #include "ITStracking/VertexerTraits.h"
 #include "ITStracking/TrackingConfigParam.h"
 
-#include <array>
-
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
-Vertexer::Vertexer(VertexerTraits* traits)
+Vertexer::Vertexer(VertexerTraits* traits) : mTraits(traits)
 {
-  if (!traits) {
+  if (!mTraits) {
     LOG(fatal) << "nullptr passed to ITS vertexer construction.";
   }
   mVertParams.resize(1);
-  mTraits = traits;
 }
 
-float Vertexer::clustersToVertices(std::function<void(std::string s)> logger)
+float Vertexer::clustersToVertices(LogFunc logger)
 {
+  LogFunc evalLog = [](const std::string&) {};
   TrackingParameters trkPars;
   TimeFrameGPUParameters tfGPUpar;
   mTraits->updateVertexingParameters(mVertParams, tfGPUpar);
   float timeTracklet{0.f}, timeSelection{0.f}, timeVertexing{0.f}, timeInit{0.f};
   for (int iteration = 0; iteration < std::min(mVertParams[0].nIterations, (int)mVertParams.size()); ++iteration) {
-    unsigned int nTracklets01, nTracklets12;
-    logger(fmt::format("ITS Seeding vertexer iteration {} summary:", iteration));
+    unsigned int nTracklets01{0}, nTracklets12{0};
+    logger(fmt::format("=== ITS {} Seeding vertexer iteration {} summary:", mTraits->getName(), iteration));
     trkPars.PhiBins = mTraits->getVertexingParameters()[0].PhiBins;
     trkPars.ZBins = mTraits->getVertexingParameters()[0].ZBins;
     auto timeInitIteration = evaluateTask(
-      &Vertexer::initialiseVertexer, "Vertexer initialisation", [](std::string) {}, trkPars, iteration);
+      &Vertexer::initialiseVertexer, " - Vertexer initialisation", evalLog, trkPars, iteration);
     auto timeTrackletIteration = evaluateTask(
-      &Vertexer::findTracklets, "Vertexer tracklet finding", [](std::string) {}, iteration);
+      &Vertexer::findTracklets, " - Vertexer tracklet finding", evalLog, iteration);
     nTracklets01 = mTimeFrame->getTotalTrackletsTF(0);
     nTracklets12 = mTimeFrame->getTotalTrackletsTF(1);
     auto timeSelectionIteration = evaluateTask(
-      &Vertexer::validateTracklets, "Vertexer tracklets validation", [](std::string) {}, iteration);
+      &Vertexer::validateTracklets, " - Vertexer tracklets validation", evalLog, iteration);
     auto timeVertexingIteration = evaluateTask(
-      &Vertexer::findVertices, "Vertexer vertex finding", [](std::string) {}, iteration);
-    printEpilog(logger, false, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), mTimeFrame->getTotVertIteration()[iteration], timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
-    timeInit += timeInitIteration;
-    timeTracklet += timeTrackletIteration;
-    timeSelection += timeSelectionIteration;
-    timeVertexing += timeVertexingIteration;
-  }
-
-  return timeInit + timeTracklet + timeSelection + timeVertexing;
-}
-
-float Vertexer::clustersToVerticesHybrid(std::function<void(std::string s)> logger)
-{
-  TrackingParameters trkPars;
-  TimeFrameGPUParameters tfGPUpar;
-  float timeTracklet, timeSelection, timeVertexing, timeInit;
-  mTraits->updateVertexingParameters(mVertParams, tfGPUpar);
-  for (int iteration = 0; iteration < std::min(mVertParams[0].nIterations, (int)mVertParams.size()); ++iteration) {
-    unsigned int nTracklets01, nTracklets12;
-    logger(fmt::format("ITS Hybrid seeding vertexer iteration {} summary:", iteration));
-    trkPars.PhiBins = mTraits->getVertexingParameters()[0].PhiBins;
-    trkPars.ZBins = mTraits->getVertexingParameters()[0].ZBins;
-    auto timeInitIteration = evaluateTask(
-      &Vertexer::initialiseVertexerHybrid, "Hybrid Vertexer initialisation", [](std::string) {}, trkPars, iteration);
-    auto timeTrackletIteration = evaluateTask(
-      &Vertexer::findTrackletsHybrid, "Hybrid Vertexer tracklet finding", [](std::string) {}, iteration);
-    nTracklets01 = mTimeFrame->getTotalTrackletsTF(0);
-    nTracklets12 = mTimeFrame->getTotalTrackletsTF(1);
-    auto timeSelectionIteration = evaluateTask(
-      &Vertexer::validateTrackletsHybrid, "Hybrid Vertexer adjacent tracklets validation", [](std::string) {}, iteration);
-    auto timeVertexingIteration = evaluateTask(
-      &Vertexer::findVerticesHybrid, "Hybrid Vertexer vertex finding", [](std::string) {}, iteration);
-
-    printEpilog(logger, true, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), mTimeFrame->getTotVertIteration()[iteration], timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
+      &Vertexer::findVertices, " - Vertexer vertex finding", evalLog, iteration);
+    printEpilog(logger, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), mTimeFrame->getTotVertIteration()[iteration], timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
     timeInit += timeInitIteration;
     timeTracklet += timeTrackletIteration;
     timeSelection += timeSelectionIteration;
@@ -135,17 +99,16 @@ void Vertexer::adoptTimeFrame(TimeFrame& tf)
   mTraits->adoptTimeFrame(&tf);
 }
 
-void Vertexer::printEpilog(std::function<void(std::string s)> logger,
-                           bool isHybrid,
-                           const unsigned int trackletN01, const unsigned int trackletN12, const unsigned selectedN, const unsigned int vertexN,
-                           const float initT, const float trackletT, const float selecT, const float vertexT)
+void Vertexer::printEpilog(LogFunc& logger,
+                           const unsigned int trackletN01, const unsigned int trackletN12,
+                           const unsigned selectedN, const unsigned int vertexN, const float initT,
+                           const float trackletT, const float selecT, const float vertexT)
 {
   float total = initT + trackletT + selecT + vertexT;
-  logger(fmt::format(" - {}Vertexer: found {} | {} tracklets in: {} ms", isHybrid ? "Hybrid " : "", trackletN01, trackletN12, trackletT));
-  logger(fmt::format(" - {}Vertexer: selected {} tracklets in: {} ms", isHybrid ? "Hybrid " : "", selectedN, selecT));
-  logger(fmt::format(" - {}Vertexer: found {} vertices in: {} ms", isHybrid ? "Hybrid " : "", vertexN, vertexT));
+  logger(fmt::format(" - {} Vertexer: found {} | {} tracklets in: {} ms", mTraits->getName(), trackletN01, trackletN12, trackletT));
+  logger(fmt::format(" - {} Vertexer: selected {} tracklets in: {} ms", mTraits->getName(), selectedN, selecT));
+  logger(fmt::format(" - {} Vertexer: found {} vertices in: {} ms", mTraits->getName(), vertexN, vertexT));
   // logger(fmt::format(" - Timeframe {} vertexing completed in: {} ms, using {} thread(s).", mTimeFrameCounter++, total, mTraits->getNThreads()));
 }
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its

Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h

@@ -28,9 +28,7 @@
 
 #include "TStopwatch.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
 class TrackerDPL : public framework::Task
@@ -61,7 +59,6 @@ class TrackerDPL : public framework::Task
 using o2::its::TrackingMode;
 framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, const std::string& trMode, const bool overrBeamEst = false, gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
 
 #endif /* O2_ITS_TRACKERDPL */