Add manual SoA

Author: OliverRietmann

GPU/Common/wrapper.h

@@ -18,6 +18,12 @@ using reference = T&;
 template <class T>
 using const_reference = const T&;
 
+template <class T>
+using pointer = T*;
+
+template <class T>
+using const_pointer = const T*;
+
 template<
     template <template <class> class> class S,
     template <class> class F,

GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx

@@ -110,7 +110,11 @@ void GPUTPCTracker::RegisterMemoryAllocation()
 
 GPUhd() void* GPUTPCTracker::SetPointersTracklets(void* mem)
 {
-  computePointerWithAlignment(mem, mTracklets, mNMaxTracklets);
+  computePointerWithAlignment(mem, mTracklets.mFirstRow, mNMaxTracklets);
+  computePointerWithAlignment(mem, mTracklets.mLastRow, mNMaxTracklets);
+  computePointerWithAlignment(mem, mTracklets.mParam, mNMaxTracklets);
+  computePointerWithAlignment(mem, mTracklets.mHitWeight, mNMaxTracklets);
+  computePointerWithAlignment(mem, mTracklets.mFirstHit, mNMaxTracklets);
   computePointerWithAlignment(mem, mTrackletRowHits, mNMaxRowHits);
   return mem;
 }

GPU/GPUTracking/SectorTracker/GPUTPCTracker.h

@@ -37,6 +37,9 @@ class GPUTPCRow;
 class GPUTPCTracker : public GPUProcessor
 {
  public:
+   template <class T> using pointer = T*;
+   template <class T> using const_reference = const T&;
+
 #ifndef GPUCA_GPUCODE_DEVICE
   GPUTPCTracker() = default;
   ~GPUTPCTracker();
@@ -183,8 +186,18 @@ class GPUTPCTracker : public GPUProcessor
   GPUhd() GPUglobalref() const GPUTPCHitId* TrackletStartHits() const { return mTrackletStartHits; }
   GPUhd() GPUglobalref() GPUTPCHitId* TrackletStartHits() { return mTrackletStartHits; }
   GPUhd() GPUglobalref() GPUTPCHitId* TrackletTmpStartHits() const { return mTrackletTmpStartHits; }
-  GPUhd() GPUglobalref() const GPUTPCTracklet& Tracklet(int32_t i) const { return mTracklets[i]; }
-  GPUhd() GPUglobalref() GPUTPCTracklet* Tracklets() const { return mTracklets; }
+
+  GPUhd() GPUglobalref() GPUTPCTracklet_reference Tracklet(int32_t i) {
+    return {
+        mTracklets.mFirstRow[i],
+        mTracklets.mLastRow[i],
+        mTracklets.mParam[i],
+        mTracklets.mHitWeight[i],
+        mTracklets.mFirstHit[i]
+    };
+  }
+
+  GPUhd() GPUglobalref() GPUTPCTracklet_pointer Tracklets() const { return mTracklets; }
   GPUhd() GPUglobalref() calink* TrackletRowHits() const { return mTrackletRowHits; }
 
   GPUhd() GPUglobalref() GPUAtomic(uint32_t) * NTracks() const { return &mCommonMem->nTracks; }
@@ -238,7 +251,7 @@ class GPUTPCTracker : public GPUProcessor
   // event
   GPUglobalref() commonMemoryStruct* mCommonMem = nullptr;  // common event memory
   GPUglobalref() GPUTPCHitId* mTrackletStartHits = nullptr; // start hits for the tracklets
-  GPUglobalref() GPUTPCTracklet* mTracklets = nullptr;      // tracklets
+  GPUglobalref() GPUTPCTracklet_pointer mTracklets;// tracklets
   GPUglobalref() calink* mTrackletRowHits = nullptr;        // Hits for each Tracklet in each row
   GPUglobalref() GPUTPCTrack* mTracks = nullptr;            // reconstructed tracks
   GPUglobalref() GPUTPCHitId* mTrackHits = nullptr;         // array of track hit numbers

GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx

@@ -129,22 +129,22 @@ void GPUTPCTracker::DumpTrackletHits(std::ostream& out)
   std::iota(Ids.begin(), Ids.end(), 0);
   if (mRec->GetProcessingSettings().deterministicGPUReconstruction) {
     std::sort(Ids.begin(), Ids.end(), [this](const int32_t& a, const int32_t& b) {
-      if (this->Tracklets()[a].FirstRow() != this->Tracklets()[b].FirstRow()) {
-        return this->Tracklets()[a].FirstRow() > this->Tracklets()[b].FirstRow();
+      if (this->Tracklet(a).FirstRow() != this->Tracklet(b).FirstRow()) {
+        return this->Tracklet(a).FirstRow() > this->Tracklet(b).FirstRow();
       }
-      if (this->Tracklets()[a].LastRow() != this->Tracklets()[b].LastRow()) {
-        return this->Tracklets()[a].LastRow() > this->Tracklets()[b].LastRow();
+      if (this->Tracklet(a).LastRow() != this->Tracklet(b).LastRow()) {
+        return this->Tracklet(a).LastRow() > this->Tracklet(b).LastRow();
       }
-      if (this->Tracklets()[a].Param().Y() != this->Tracklets()[b].Param().Y()) {
-        return this->Tracklets()[a].Param().Y() > this->Tracklets()[b].Param().Y();
+      if (this->Tracklet(a).Param().Y() != this->Tracklet(b).Param().Y()) {
+        return this->Tracklet(a).Param().Y() > this->Tracklet(b).Param().Y();
       }
-      return this->Tracklets()[a].Param().Z() > this->Tracklets()[b].Param().Z();
+      return this->Tracklet(a).Param().Z() > this->Tracklet(b).Param().Z();
     });
   }
   for (int32_t jj = 0; jj < nTracklets; jj++) {
     const int32_t j = Ids[jj];
-    const auto& tracklet = Tracklets()[j];
-    out << "Tracklet " << std::setw(4) << jj << " (Rows: " << Tracklets()[j].FirstRow() << " - " << tracklet.LastRow() << ", Weight " << Tracklets()[j].HitWeight() << ") ";
+    const auto& tracklet = Tracklet(j);
+    out << "Tracklet " << std::setw(4) << jj << " (Rows: " << Tracklet(j).FirstRow() << " - " << tracklet.LastRow() << ", Weight " << Tracklet(j).HitWeight() << ") ";
     if (tracklet.LastRow() > tracklet.FirstRow() && (tracklet.FirstRow() >= GPUCA_ROW_COUNT || tracklet.LastRow() >= GPUCA_ROW_COUNT)) {
       GPUError("Error: Tracklet %d First %d Last %d", j, tracklet.FirstRow(), tracklet.LastRow());
       out << " (Error: Tracklet " << j << " First " << tracklet.FirstRow() << " Last " << tracklet.LastRow() << ") ";

GPU/GPUTracking/SectorTracker/GPUTPCTracklet.h

@@ -17,6 +17,7 @@
 
 #include "GPUTPCBaseTrackParam.h"
 #include "GPUTPCDef.h"
+#include "wrapper.h"
 
 namespace o2::gpu
 {
@@ -26,11 +27,12 @@ namespace o2::gpu
  * The class describes the reconstructed TPC track candidate.
  * The class is dedicated for internal use by the GPUTPCTracker algorithm.
  */
-class GPUTPCTracklet
+template <template <class> class F>
+class GPUTPCTrackletSkeleton
 {
  public:
 #if !defined(GPUCA_GPUCODE)
-  GPUTPCTracklet() : mFirstRow(0), mLastRow(0), mParam(), mHitWeight(0), mFirstHit(0) {};
+  //GPUTPCTrackletSkeleton() : mFirstRow(0), mLastRow(0), mParam(), mHitWeight(0), mFirstHit(0) {};
 #endif //! GPUCA_GPUCODE
 
   GPUhd() int32_t FirstRow() const { return mFirstRow; }
@@ -45,13 +47,19 @@ class GPUTPCTracklet
   GPUhd() void SetParam(const GPUTPCBaseTrackParam& v) { mParam = reinterpret_cast<const GPUTPCBaseTrackParam&>(v); }
   GPUhd() void SetHitWeight(const int32_t w) { mHitWeight = w; }
 
- private:
-  int32_t mFirstRow;           // first TPC row // TODO: We can use smaller data format here!
-  int32_t mLastRow;            // last TPC row
-  GPUTPCBaseTrackParam mParam; // tracklet parameters
-  int32_t mHitWeight;          // Hit Weight of Tracklet
-  uint32_t mFirstHit;          // first hit in row hit array
+// private:
+  F<int32_t> mFirstRow;           // first TPC row // TODO: We can use smaller data format here!
+  F<int32_t> mLastRow;            // last TPC row
+  F<GPUTPCBaseTrackParam> mParam; // tracklet parameters -- GPUTPCBaseTrackParamSkeleton<F>
+  F<int32_t> mHitWeight;          // Hit Weight of Tracklet
+  F<uint32_t> mFirstHit;          // first hit in row hit array
 };
+
+using GPUTPCTracklet = GPUTPCTrackletSkeleton<wrapper::value>;
+using GPUTPCTracklet_reference = GPUTPCTrackletSkeleton<wrapper::reference>;
+using GPUTPCTracklet_const_reference = GPUTPCTrackletSkeleton<wrapper::const_reference>;
+using GPUTPCTracklet_pointer = GPUTPCTrackletSkeleton<wrapper::pointer>;
+
 } // namespace o2::gpu
 
 #endif // GPUTPCTRACKLET_H

GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx

@@ -78,7 +78,7 @@ GPUd() void GPUTPCTrackletConstructor::StoreTracklet(int32_t /*nBlocks*/, int32_
     return;
   }
 
-  GPUglobalref() GPUTPCTracklet& GPUrestrict() tracklet = tracker.Tracklets()[itrout];
+  GPUglobalref() GPUTPCTracklet_reference GPUrestrict() tracklet = tracker.Tracklet(itrout);
 
   CADEBUG(printf("    Storing tracklet: %d rows\n", nHits));
 

GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx

@@ -39,7 +39,7 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
   for (int32_t itr = s.mItr0 + iThread; itr < s.mNTracklets; itr += s.mNThreadsTotal) {
     GPUbarrierWarp();
 
-    GPUglobalref() GPUTPCTracklet& GPUrestrict() tracklet = tracker.Tracklets()[itr];
+    GPUglobalref() GPUTPCTracklet_reference GPUrestrict() tracklet = tracker.Tracklet(itr);
 
     int32_t firstRow = tracklet.FirstRow();
     int32_t lastRow = tracklet.LastRow();