TPCFastTransform: Do not pollute the global namespace

davidrohr · davidrohr · commit 3b23e9a1471f · 2026-04-13T20:59:53.000+02:00
diff --git a/Detectors/Base/src/MatLayerCyl.cxx b/Detectors/Base/src/MatLayerCyl.cxx
@@ -83,7 +83,7 @@ void MatLayerCyl::initSegmentation(float rMin, float rMax, float zHalfSpan, int
   //
   int offs = 0;
 
-  o2::gpu::resizeArray(mPhiBin2Slice, 0, nphi, reinterpret_cast<short*>(mFlatBufferPtr + offs));
+  o2::gpu::FlatObject::FlatObject::resizeArray(mPhiBin2Slice, 0, nphi, reinterpret_cast<short*>(mFlatBufferPtr + offs));
   mNPhiSlices = mNPhiBins = nphi;
 
   for (int i = nphi; i--;) {
@@ -92,18 +92,18 @@ void MatLayerCyl::initSegmentation(float rMin, float rMax, float zHalfSpan, int
 
   offs = alignSize(offs + nphi * sizeof(short), getBufferAlignmentBytes()); // account for alignment
 
-  o2::gpu::resizeArray(mSliceCos, 0, nphi, reinterpret_cast<float*>(mFlatBufferPtr + offs)); // in the beginning nslice = nphi
+  o2::gpu::FlatObject::resizeArray(mSliceCos, 0, nphi, reinterpret_cast<float*>(mFlatBufferPtr + offs)); // in the beginning nslice = nphi
   offs = alignSize(offs + nphi * sizeof(float), getBufferAlignmentBytes());                  // account for alignment
 
-  o2::gpu::resizeArray(mSliceSin, 0, nphi, reinterpret_cast<float*>(mFlatBufferPtr + offs)); // in the beginning nslice = nphi
+  o2::gpu::FlatObject::resizeArray(mSliceSin, 0, nphi, reinterpret_cast<float*>(mFlatBufferPtr + offs)); // in the beginning nslice = nphi
   offs = alignSize(offs + nphi * sizeof(float), getBufferAlignmentBytes());                  // account for alignment
 
   for (int i = nphi; i--;) {
     mSliceCos[i] = o2::math_utils::cos(getPhiBinMin(i));
     mSliceSin[i] = o2::math_utils::sin(getPhiBinMin(i));
   }
 
-  o2::gpu::resizeArray(mCells, 0, getNCells(), reinterpret_cast<MatCell*>(mFlatBufferPtr + offs));
+  o2::gpu::FlatObject::resizeArray(mCells, 0, getNCells(), reinterpret_cast<MatCell*>(mFlatBufferPtr + offs));
 
   mConstructionMask = InProgress;
 }
@@ -245,10 +245,10 @@ void MatLayerCyl::optimizePhiSlices(float maxRelDiff)
   // mSliceCos pointer does not change, but sliceSin needs to be relocated
   auto offs = alignSize(newSl * sizeof(float), getBufferAlignmentBytes());
   char* dst = ((char*)mSliceCos) + offs; // account for alignment
-  o2::gpu::resizeArray(mSliceSin, getNPhiBins(), newSl, reinterpret_cast<float*>(dst));
+  o2::gpu::FlatObject::resizeArray(mSliceSin, getNPhiBins(), newSl, reinterpret_cast<float*>(dst));
   // adjust mCells array
   dst = ((char*)mSliceSin) + offs; // account for alignment
-  o2::gpu::resizeArray(mCells, getNPhiBins() * getNZBins(), newSl * getNZBins(), reinterpret_cast<MatCell*>(dst));
+  o2::gpu::FlatObject::resizeArray(mCells, getNPhiBins() * getNZBins(), newSl * getNZBins(), reinterpret_cast<MatCell*>(dst));
   mFlatBufferSize = estimateFlatBufferSize();
   LOG(info) << "Updated Nslices = " << getNPhiSlices();
 }
@@ -313,7 +313,7 @@ void MatLayerCyl::flatten(char* newPtr)
   // make object flat: move all content to single internally allocated buffer
   assert(mConstructionMask == InProgress);
   fixPointers(mFlatBufferPtr, newPtr);
-  auto old = o2::gpu::resizeArray(mFlatBufferPtr, getFlatBufferSize(), getFlatBufferSize(), newPtr);
+  auto old = o2::gpu::FlatObject::resizeArray(mFlatBufferPtr, getFlatBufferSize(), getFlatBufferSize(), newPtr);
   delete[] old;
   mFlatBufferContainer = nullptr;
   mConstructionMask = Constructed;
diff --git a/Detectors/Base/src/MatLayerCylSet.cxx b/Detectors/Base/src/MatLayerCylSet.cxx
@@ -39,7 +39,7 @@ void MatLayerCylSet::addLayer(float rmin, float rmax, float zmax, float dz, floa
   if (!nlr) {
     // book local storage
     auto sz = sizeof(MatLayerCylSetLayout);
-    o2::gpu::resizeArray(mFlatBufferContainer, 0, sz);
+    o2::gpu::FlatObject::resizeArray(mFlatBufferContainer, 0, sz);
     mFlatBufferPtr = mFlatBufferContainer;
     mFlatBufferSize = sz;
     //--------------????
@@ -53,7 +53,7 @@ void MatLayerCylSet::addLayer(float rmin, float rmax, float zmax, float dz, floa
       LOG(fatal) << "new layer overlaps with layer " << il;
     }
   }
-  auto* oldLayers = o2::gpu::resizeArray(get()->mLayers, nlr, nlr + 1);
+  auto* oldLayers = o2::gpu::FlatObject::resizeArray(get()->mLayers, nlr, nlr + 1);
   // dynamyc buffers of old layers were used in new ones, detach them
   for (int i = nlr; i--;) {
     oldLayers[i].clearInternalBufferPtr();
@@ -98,8 +98,8 @@ void MatLayerCylSet::finalizeStructures()
   assert(mConstructionMask == InProgress);
   int nlr = getNLayers();
   int nR2Int = 2 * (nlr + 1);
-  o2::gpu::resizeArray(get()->mR2Intervals, 0, nR2Int);
-  o2::gpu::resizeArray(get()->mInterval2LrID, 0, nR2Int);
+  o2::gpu::FlatObject::resizeArray(get()->mR2Intervals, 0, nR2Int);
+  o2::gpu::FlatObject::resizeArray(get()->mInterval2LrID, 0, nR2Int);
   get()->mR2Intervals[0] = get()->mRMin2;
   get()->mR2Intervals[1] = get()->mRMax2;
   get()->mInterval2LrID[0] = 0;
@@ -116,8 +116,8 @@ void MatLayerCylSet::finalizeStructures()
     get()->mInterval2LrID[nRIntervals] = i;
     get()->mR2Intervals[++nRIntervals] = lr.getRMax2();
   }
-  delete[] o2::gpu::resizeArray(get()->mInterval2LrID, nR2Int, nRIntervals); // rebook with precise size
-  delete[] o2::gpu::resizeArray(get()->mR2Intervals, nR2Int, ++nRIntervals); // rebook with precise size
+  delete[] o2::gpu::FlatObject::resizeArray(get()->mInterval2LrID, nR2Int, nRIntervals); // rebook with precise size
+  delete[] o2::gpu::FlatObject::resizeArray(get()->mR2Intervals, nR2Int, ++nRIntervals); // rebook with precise size
   //
 }
 
@@ -508,14 +508,14 @@ void MatLayerCylSet::flatten()
 
   int sz = estimateFlatBufferSize();
   // create new internal buffer with total size and copy data
-  delete[] o2::gpu::resizeArray(mFlatBufferContainer, mFlatBufferSize, sz);
+  delete[] o2::gpu::FlatObject::resizeArray(mFlatBufferContainer, mFlatBufferSize, sz);
   mFlatBufferPtr = mFlatBufferContainer;
   mFlatBufferSize = sz;
   int nLr = getNLayers();
 
   auto offs = alignSize(sizeof(MatLayerCylSetLayout), getBufferAlignmentBytes()); // account for the alignment
   // move array of layer pointers to the flat array
-  auto* oldLayers = o2::gpu::resizeArray(get()->mLayers, nLr, nLr, (MatLayerCyl*)(mFlatBufferPtr + offs));
+  auto* oldLayers = o2::gpu::FlatObject::resizeArray(get()->mLayers, nLr, nLr, (MatLayerCyl*)(mFlatBufferPtr + offs));
   // dynamyc buffers of old layers were used in new ones, detach them
   for (int i = nLr; i--;) {
     oldLayers[i].clearInternalBufferPtr();
@@ -524,11 +524,11 @@ void MatLayerCylSet::flatten()
   offs = alignSize(offs + nLr * sizeof(MatLayerCyl), MatLayerCyl::getClassAlignmentBytes()); // account for the alignment
 
   // move array of R2 boundaries to the flat array
-  delete[] o2::gpu::resizeArray(get()->mR2Intervals, nLr + 1, nLr + 1, (float*)(mFlatBufferPtr + offs));
+  delete[] o2::gpu::FlatObject::resizeArray(get()->mR2Intervals, nLr + 1, nLr + 1, (float*)(mFlatBufferPtr + offs));
   offs = alignSize(offs + (nLr + 1) * sizeof(float), getBufferAlignmentBytes()); // account for the alignment
 
   // move array of R2 boundaries to the flat array
-  delete[] o2::gpu::resizeArray(get()->mInterval2LrID, nLr, nLr, (int*)(mFlatBufferPtr + offs));
+  delete[] o2::gpu::FlatObject::resizeArray(get()->mInterval2LrID, nLr, nLr, (int*)(mFlatBufferPtr + offs));
   offs = alignSize(offs + nLr * sizeof(int), getBufferAlignmentBytes()); // account for the alignment
 
   for (int il = 0; il < nLr; il++) {
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -115,7 +115,7 @@ class TPCFastTransform : public FlatObject
   }
 
 /// Destructor
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_GPUCODE)
   ~TPCFastTransform()
   {
     delete mCorrectionSlow;
diff --git a/GPU/Utils/FlatObject.h b/GPU/Utils/FlatObject.h
@@ -115,63 +115,6 @@ namespace gpu
 ///  before the transport. The object will be ready-to-use right after the porting.
 ///
 
-#ifndef GPUCA_GPUCODE // code invisible on GPU
-
-template <typename T>
-T* resizeArray(T*& ptr, int32_t oldSize, int32_t newSize, T* newPtr = nullptr)
-{
-  // Resize array pointed by ptr. T must be a POD class.
-  // If the non-null newPtr is provided, use it instead of allocating a new one.
-  // In this case it is up to the user to ensure that it has at least newSize slots allocated.
-  // Return original array pointer, so that the user can manage previously allocate memory
-  if (oldSize < 0) {
-    oldSize = 0;
-  }
-  if (newSize > 0) {
-    if (!newPtr) {
-      newPtr = new T[newSize];
-    }
-    int32_t mcp = std::min(newSize, oldSize);
-    if (mcp) {
-      assert(ptr);
-      std::memmove(newPtr, ptr, mcp * sizeof(T));
-    }
-    if (newSize > oldSize) {
-      std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T));
-    }
-  }
-  T* oldPtr = ptr;
-  ptr = newPtr;
-  return oldPtr;
-}
-
-template <typename T>
-T** resizeArray(T**& ptr, int32_t oldSize, int32_t newSize, T** newPtr = nullptr)
-{
-  // Resize array of pointers pointed by ptr.
-  // If the non-null newPtr is provided, use it instead of allocating a new one.
-  // In this case it is up to the user to ensure that it has at least newSize slots allocated.
-  // Return original array pointer, so that the user can manage previously allocate memory
-  if (oldSize < 0) {
-    oldSize = 0;
-  }
-  if (newSize > 0) {
-    if (!newPtr) {
-      newPtr = new T*[newSize];
-    }
-    int32_t mcp = std::min(newSize, oldSize);
-    std::memmove(newPtr, ptr, mcp * sizeof(T*));
-    if (newSize > oldSize) {
-      std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T*));
-    }
-  }
-  T** oldPtr = ptr;
-  ptr = newPtr;
-  return oldPtr;
-}
-
-#endif //! GPUCA_GPUCODE
-
 class FlatObject
 {
  public:
@@ -187,6 +130,61 @@ class FlatObject
   FlatObject() = delete;
 #endif
 
+#ifndef GPUCA_GPUCODE // code invisible on GPU
+  template <typename T>
+  T* resizeArray(T*& ptr, int32_t oldSize, int32_t newSize, T* newPtr = nullptr)
+  {
+    // Resize array pointed by ptr. T must be a POD class.
+    // If the non-null newPtr is provided, use it instead of allocating a new one.
+    // In this case it is up to the user to ensure that it has at least newSize slots allocated.
+    // Return original array pointer, so that the user can manage previously allocate memory
+    if (oldSize < 0) {
+      oldSize = 0;
+    }
+    if (newSize > 0) {
+      if (!newPtr) {
+        newPtr = new T[newSize];
+      }
+      int32_t mcp = std::min(newSize, oldSize);
+      if (mcp) {
+        assert(ptr);
+        std::memmove(newPtr, ptr, mcp * sizeof(T));
+      }
+      if (newSize > oldSize) {
+        std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T));
+      }
+    }
+    T* oldPtr = ptr;
+    ptr = newPtr;
+    return oldPtr;
+  }
+
+  template <typename T>
+  T** resizeArray(T**& ptr, int32_t oldSize, int32_t newSize, T** newPtr = nullptr)
+  {
+    // Resize array of pointers pointed by ptr.
+    // If the non-null newPtr is provided, use it instead of allocating a new one.
+    // In this case it is up to the user to ensure that it has at least newSize slots allocated.
+    // Return original array pointer, so that the user can manage previously allocate memory
+    if (oldSize < 0) {
+      oldSize = 0;
+    }
+    if (newSize > 0) {
+      if (!newPtr) {
+        newPtr = new T*[newSize];
+      }
+      int32_t mcp = std::min(newSize, oldSize);
+      std::memmove(newPtr, ptr, mcp * sizeof(T*));
+      if (newSize > oldSize) {
+        std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T*));
+      }
+    }
+    T** oldPtr = ptr;
+    ptr = newPtr;
+    return oldPtr;
+  }
+#endif //! GPUCA_GPUCODE
+
  protected:
   /// _____________  Memory alignment  __________________________
 

Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ class TPCFastTransform : public FlatObject`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`/// Destructor`
`118`		`-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)`
	`118`	`+#if !defined(GPUCA_GPUCODE)`
`119`	`119`	`~TPCFastTransform()`
`120`	`120`	`{`
`121`	`121`	`delete mCorrectionSlow;`