ITS: fix gpu compile due change in vertexer types

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

Author: f3sch

Detectors/ITSMFT/ITS/tracking/CMakeLists.txt

@@ -19,7 +19,6 @@ o2_add_library(ITStracking
                        src/Tracker.cxx
                        src/TrackerTraits.cxx
                        src/TrackingConfigParam.cxx
-                       src/ClusterLines.cxx
                        src/Vertexer.cxx
                        src/VertexerTraits.cxx
                PUBLIC_LINK_LIBRARIES

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

@@ -24,7 +24,7 @@
 namespace o2::its::gpu
 {
 
-template <int NLayers = 7>
+template <int NLayers>
 class TimeFrameGPU final : public TimeFrame<NLayers>
 {
   using typename TimeFrame<NLayers>::CellSeedN;
@@ -34,7 +34,7 @@ class TimeFrameGPU final : public TimeFrame<NLayers>
 
  public:
   TimeFrameGPU() = default;
-  ~TimeFrameGPU() = default;
+  ~TimeFrameGPU() final = default;
 
   /// Most relevant operations
   void pushMemoryStack(const int);
@@ -104,7 +104,6 @@ class TimeFrameGPU final : public TimeFrame<NLayers>
   /// interface
   virtual bool isGPU() const noexcept final { return true; }
   virtual const char* getName() const noexcept { return "GPU"; }
-  int getNClustersInRofSpan(const int, const int, const int) const;
   IndexTableUtilsN* getDeviceIndexTableUtils() { return mIndexTableUtilsDevice; }
   const auto getDeviceROFOverlapTableView() { return mDeviceROFOverlapTableView; }
   const auto getDeviceROFVertexLookupTableView() { return mDeviceROFVertexLookupTableView; }
@@ -144,19 +143,6 @@ class TimeFrameGPU final : public TimeFrame<NLayers>
   int* getDeviceNeighboursIndexTables(const int layer) { return mNeighboursIndexTablesDevice[layer]; }
   uint8_t* getDeviceMultCutMask() { return mMultMaskDevice; }
 
-  // Vertexer
-  auto& getDeviceNTrackletsPerROF() const noexcept { return mNTrackletsPerROFDevice; }
-  auto& getDeviceNTrackletsPerCluster() const noexcept { return mNTrackletsPerClusterDevice; }
-  auto& getDeviceNTrackletsPerClusterSum() const noexcept { return mNTrackletsPerClusterSumDevice; }
-  int32_t** getDeviceArrayNTrackletsPerROF() const noexcept { return mNTrackletsPerROFDeviceArray; }
-  int32_t** getDeviceArrayNTrackletsPerCluster() const noexcept { return mNTrackletsPerClusterDeviceArray; }
-  int32_t** getDeviceArrayNTrackletsPerClusterSum() const noexcept { return mNTrackletsPerClusterSumDeviceArray; }
-  uint8_t* getDeviceUsedTracklets() const noexcept { return mUsedTrackletsDevice; }
-  int32_t* getDeviceNLinesPerCluster() const noexcept { return mNLinesPerClusterDevice; }
-  int32_t* getDeviceNLinesPerClusterSum() const noexcept { return mNLinesPerClusterSumDevice; }
-  Line* getDeviceLines() const noexcept { return mLinesDevice; }
-  gsl::span<int*> getDeviceTrackletsPerROFs() { return mNTrackletsPerROFDevice; }
-
   void setDevicePropagator(const o2::base::PropagatorImpl<float>* p) final { this->mPropagatorDevice = p; }
 
   // Host-specific getters
@@ -233,18 +219,6 @@ class TimeFrameGPU final : public TimeFrame<NLayers>
   std::array<TrackingFrameInfo*, NLayers> mTrackingFrameInfoDevice;
   const TrackingFrameInfo** mTrackingFrameInfoDeviceArray;
 
-  /// Vertexer
-  std::array<int32_t*, 2> mNTrackletsPerROFDevice;
-  std::array<int32_t*, 2> mNTrackletsPerClusterDevice;
-  std::array<int32_t*, 2> mNTrackletsPerClusterSumDevice;
-  uint8_t* mUsedTrackletsDevice;
-  int32_t* mNLinesPerClusterDevice;
-  int32_t* mNLinesPerClusterSumDevice;
-  int32_t** mNTrackletsPerROFDeviceArray;
-  int32_t** mNTrackletsPerClusterDeviceArray;
-  int32_t** mNTrackletsPerClusterSumDeviceArray;
-  Line* mLinesDevice;
-
   // State
   Streams mGpuStreams;
   std::bitset<NLayers + 1> mPinnedUnsortedClusters{0};
@@ -258,12 +232,6 @@ class TimeFrameGPU final : public TimeFrame<NLayers>
   bounded_vector<TrackITSExt> mTrackITSExt;
 };
 
-template <int NLayers>
-inline int TimeFrameGPU<NLayers>::getNClustersInRofSpan(const int rofIdstart, const int rofSpanSize, const int layerId) const
-{
-  return static_cast<int>(this->mROFramesClusters[layerId][(rofIdstart + rofSpanSize) < this->mROFramesClusters.size() ? rofIdstart + rofSpanSize : this->mROFramesClusters.size() - 1] - this->mROFramesClusters[layerId][rofIdstart]);
-}
-
 template <int NLayers>
 inline std::vector<unsigned int> TimeFrameGPU<NLayers>::getClusterSizes()
 {

Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt

@@ -19,6 +19,7 @@ if(CUDA_ENABLED)
                            TrackingKernels.cu
                    PUBLIC_INCLUDE_DIRECTORIES ../
                    PUBLIC_LINK_LIBRARIES O2::ITStracking
+                                         O2::MathUtils
                                          O2::SimConfig
                                          O2::SimulationDataFormat
                                          O2::ReconstructionDataFormats
@@ -29,10 +30,11 @@ if(CUDA_ENABLED)
     set_target_gpu_arch("CUDA" ${targetName})
     # Enable relocatable device code (needed for separable compilation + debugging)
     set_property(TARGET ${targetName} PROPERTY CUDA_SEPARABLE_COMPILATION ON)
-    # target_compile_options(${targetName} PRIVATE
+    target_compile_options(${targetName} PRIVATE
+        $<$<COMPILE_LANGUAGE:CUDA>:-diag-error=20014>
     #     $<$<COMPILE_LANGUAGE:CUDA>:-G;-O0;-Xptxas=-O0>
     #     $<$<COMPILE_LANGUAGE:CXX>:-O0;-g>
-    # )
+    )
     # target_compile_definitions(${targetName} PRIVATE ITS_MEASURE_GPU_TIME ITS_GPU_LOG)
     target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::ITStracking,COMPILE_DEFINITIONS>)
 endif()

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

@@ -16,15 +16,16 @@
 #include <vector>
 #include <Math/SMatrix.h>
 #include <Math/SVector.h>
-#include "Framework/Logger.h"
 #include "ITStracking/Cluster.h"
 #include "ITStracking/Constants.h"
 #include "ITStracking/Tracklet.h"
+#include "GPUCommonRtypes.h"
 
 namespace o2::its
 {
 
 struct Line final {
+#if !defined(__HIPCC__) && !defined(__CUDACC__) // hide the class completely for gpu-cc
   using SVector3f = ROOT::Math::SVector<float, 3>;
   using SMatrix3f = ROOT::Math::SMatrix<float, 3, 3, ROOT::Math::MatRepSym<float, 3>>;
 
@@ -34,23 +35,20 @@ struct Line final {
   static float getDistanceFromPoint(const Line& line, const std::array<float, 3>& point);
   static SMatrix3f getDCAComponents(const Line& line, const std::array<float, 3>& point);
   static float getDCA(const Line&, const Line&, const float precision = constants::Tolerance);
-  bool isEmpty() const { return ROOT::Math::Dot(originPoint, originPoint) == 0.f &&
-                                ROOT::Math::Dot(cosinesDirector, cosinesDirector) == 0.f; }
+  bool isEmpty() const noexcept;
   bool operator==(const Line&) const = default;
-  void print() const
-  {
-    LOGP(info, "TRKLT: x={} y={} z={} dx={} dy={} dz={} ts:{}+/-{}", originPoint(0), originPoint(1), originPoint(2), cosinesDirector(0), cosinesDirector(1), cosinesDirector(2), mTime.getTimeStamp(), mTime.getTimeStampError());
-  }
 
   SVector3f originPoint;
   SVector3f cosinesDirector;
   TimeEstBC mTime;
 
   ClassDefNV(Line, 1);
+#endif
 };
 
 class ClusterLines final
 {
+#if !defined(__HIPCC__) && !defined(__CUDACC__) // hide the class completely for gpu-cc
   using SMatrix3 = ROOT::Math::SMatrix<double, 3, 3, ROOT::Math::MatRepSym<double, 3>>;
   using SMatrix3f = ROOT::Math::SMatrix<float, 3, 3, ROOT::Math::MatRepSym<float, 3>>;
   using SVector3 = ROOT::Math::SVector<double, 3>;
@@ -81,6 +79,9 @@ class ClusterLines final
   bool mIsValid = false;             // true if linear system was solved successfully
   TimeEstBC mTime;                   // time stamp
   std::vector<int> mLabels;          // contributing labels
+
+  ClassDefNV(ClusterLines, 1);
+#endif
 };
 
 } // namespace o2::its

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

@@ -38,7 +38,7 @@ namespace its
 {
 class TrackITSExt;
 
-template <int NLayers = 7>
+template <int NLayers>
 class TrackerTraits
 {
  public:

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

@@ -71,6 +71,12 @@ Line::SMatrix3f Line::getDCAComponents(const Line& line, const std::array<float,
   return m;
 }
 
+bool Line::isEmpty() const noexcept
+{
+  return ROOT::Math::Dot(originPoint, originPoint) == 0.f &&
+         ROOT::Math::Dot(cosinesDirector, cosinesDirector) == 0.f;
+}
+
 // Accumulate the weighted normal equation contributions (A matrix and B vector)
 // from a single line into the running sums. The covariance is assumed to be
 // diagonal and uniform ({1,1,1}) so the weights simplify accordingly.

GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu

@@ -94,15 +94,13 @@ GPUReconstruction* GPUReconstruction_Create_CUDA(const GPUSettingsDeviceBackend&
 void GPUReconstructionCUDA::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits<7>>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame)
 {
   if (trackerTraits) {
-    trackerTraits->reset(new o2::its::TrackerTraitsGPU);
+    trackerTraits->reset(new o2::its::TrackerTraitsGPU<7>);
   }
   if (vertexerTraits) {
     vertexerTraits->reset(new o2::its::VertexerTraits<7>);
-    // TODO gpu-code to be implemented then remove line above and uncomment line below
-    // vertexerTraits->reset(new o2::its::VertexerTraitsGPU<7>);
   }
   if (timeFrame) {
-    timeFrame->reset(new o2::its::gpu::TimeFrameGPU);
+    timeFrame->reset(new o2::its::gpu::TimeFrameGPU<7>);
   }
 }