GPU: Use GPUCommonAlignedAlloc.h in more places

davidrohr · davidrohr · commit 5fc295d9f2e6 · 2026-04-13T20:59:53.000+02:00
diff --git a/GPU/Common/GPUCommonAlignedAlloc.h b/GPU/Common/GPUCommonAlignedAlloc.h
@@ -22,17 +22,17 @@ namespace o2::gpu
 
 template <typename T, std::size_t MIN_ALIGN = 0>
 struct alignedDeleter {
-  void operator()(void* ptr) { ::operator delete(ptr, std::align_val_t(std::max(MIN_ALIGN, alignof(T)))); };
+  void operator()(void* ptr) { ::operator delete(ptr, std::align_val_t(std::max(MIN_ALIGN, alignof(T)))); }; // TODO: Make this static once we go to C++ 23
 };
 
 template <typename T, std::size_t MIN_ALIGN = 0>
 struct alignedAllocator {
   using value_type = T;
-  T* allocate(std::size_t n)
+  static T* allocate(std::size_t n)
   {
     return (T*)::operator new(n, std::align_val_t(std::max(MIN_ALIGN, alignof(T))));
   }
-  void deallocate(T* ptr, std::size_t)
+  static void deallocate(T* ptr, std::size_t)
   {
     alignedDeleter<T, MIN_ALIGN>()(ptr);
   }
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -467,7 +467,7 @@ int32_t GPUReconstruction::Exit()
       if (mMemoryResources[i].mReuse >= 0) {
         continue;
       }
-      ::operator delete(mMemoryResources[i].mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+      alignedDefaultBufferDeleter()(mMemoryResources[i].mPtrDevice);
       mMemoryResources[i].mPtr = mMemoryResources[i].mPtrDevice = nullptr;
     }
   }
@@ -630,7 +630,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && (control == nullptr || control->useInternal())) {
     if (!(res->mType & GPUMemoryResource::MEMORY_EXTERNAL)) {
       if (res->mPtrDevice && res->mReuse < 0) {
-        ::operator delete(res->mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+        alignedDefaultBufferDeleter()(res->mPtrDevice);
       }
       res->mSize = std::max((size_t)res->SetPointers((void*)1) - 1, res->mOverrideSize);
       if (res->mReuse >= 0) {
@@ -640,7 +640,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
         }
         res->mPtrDevice = mMemoryResources[res->mReuse].mPtrDevice;
       } else {
-        res->mPtrDevice = ::operator new(res->mSize + constants::GPU_BUFFER_ALIGNMENT, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+        res->mPtrDevice = alignedDefaultBufferAllocator<char>(res->mSize + constants::GPU_BUFFER_ALIGNMENT);
       }
       res->mPtr = GPUProcessor::alignPointer<constants::GPU_BUFFER_ALIGNMENT>(res->mPtrDevice);
       res->SetPointers(res->mPtr);
@@ -731,7 +731,7 @@ void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
 {
   stdspinlock spinlock(mMemoryMutex);
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
-    char* retVal = new (std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)) char[size];
+    char* retVal = alignedDefaultBufferAllocator<char>(size);
     if ((type & GPUMemoryResource::MEMORY_STACK)) {
       mNonPersistentIndividualDirectAllocations.emplace_back(retVal, alignedDefaultBufferDeleter());
     } else {
@@ -796,7 +796,7 @@ void* GPUReconstruction::AllocateVolatileMemory(size_t size, bool device)
   if (device) {
     return AllocateVolatileDeviceMemory(size);
   }
-  char* retVal = new (std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)) char[size];
+  char* retVal = alignedDefaultBufferAllocator<char>(size);
   stdspinlock spinlock(mMemoryMutex);
   mVolatileChunks.emplace_back(retVal, alignedDefaultBufferDeleter());
   return retVal;
@@ -876,7 +876,7 @@ void GPUReconstruction::FreeRegisteredMemory(GPUMemoryResource* res)
     std::cout << "Freeing " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";
   }
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && res->mReuse < 0) {
-    ::operator delete(res->mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+    alignedDefaultBufferDeleter()(res->mPtrDevice);
   }
   res->mPtr = nullptr;
   res->mPtrDevice = nullptr;
@@ -916,7 +916,7 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag, cons
       std::cout << "Freeing NonPersistent " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";
     }
     if (res->mReuse < 0) {
-      ::operator delete(res->mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+      alignedDefaultBufferDeleter()(res->mPtrDevice);
     }
     res->mPtr = nullptr;
     res->mPtrDevice = nullptr;
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -253,6 +253,13 @@ class GPUReconstruction
   static int32_t getHostThreadIndex();
   int32_t GetMaxBackendThreads() const { return mMaxBackendThreads; }
 
+  using alignedDefaultBufferDeleter = alignedDeleter<char, constants::GPU_BUFFER_ALIGNMENT>;
+  template <typename T>
+  static T* alignedDefaultBufferAllocator(size_t n)
+  {
+    return alignedAllocator<char, constants::GPU_BUFFER_ALIGNMENT>::allocate(n); // Note that char is correct, since the buffer is a char buffer
+  }
+
  protected:
   void AllocateRegisteredMemoryInternal(GPUMemoryResource* res, GPUOutputControl* control, GPUReconstruction* recPool);
   void FreeRegisteredMemory(GPUMemoryResource* res);
@@ -387,7 +394,6 @@ class GPUReconstruction
   std::unordered_map<GPUMemoryReuse::ID, MemoryReuseMeta> mMemoryReuse1to1;
   std::vector<std::tuple<void*, void*, size_t, size_t, uint64_t>> mNonPersistentMemoryStack; // hostPoolAddress, devicePoolAddress, individualAllocationCount, directIndividualAllocationCound, tag
   std::vector<GPUMemoryResource*> mNonPersistentIndividualAllocations;
-  using alignedDefaultBufferDeleter = alignedDeleter<char, constants::GPU_BUFFER_ALIGNMENT>;
   std::vector<std::unique_ptr<char[], alignedDefaultBufferDeleter>> mNonPersistentIndividualDirectAllocations;
   std::vector<std::unique_ptr<char[], alignedDefaultBufferDeleter>> mDirectMemoryChunks;
   std::vector<std::unique_ptr<char[], alignedDefaultBufferDeleter>> mVolatileChunks;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -189,7 +189,7 @@ int32_t GPUReconstructionCPU::InitDevice()
       if (mDeviceMemorySize > mHostMemorySize) {
         mHostMemorySize = mDeviceMemorySize;
       }
-      mHostMemoryBase = ::operator new(mHostMemorySize, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+      mHostMemoryBase = alignedDefaultBufferAllocator<char>(mHostMemorySize);
     }
     mHostMemoryPermanent = mHostMemoryBase;
     ClearAllocatedMemory();
@@ -205,7 +205,7 @@ int32_t GPUReconstructionCPU::ExitDevice()
 {
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
     if (mMaster == nullptr) {
-      ::operator delete(mHostMemoryBase, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+      alignedDefaultBufferDeleter()(mHostMemoryBase);
     }
     mHostMemoryPool = mHostMemoryBase = mHostMemoryPoolEnd = mHostMemoryPermanent = nullptr;
     mHostMemorySize = 0;
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -81,11 +81,7 @@ uint32_t syncAsyncDecodedClusters = 0;
 GPUChainTracking *chainTracking, *chainTrackingAsync, *chainTrackingPipeline;
 GPUChainITS *chainITS, *chainITSAsync, *chainITSPipeline;
 std::string eventsDir;
-void unique_ptr_aligned_delete(char* v)
-{
-  ::operator delete(v, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
-}
-std::unique_ptr<char, void (*)(char*)> outputmemory(nullptr, unique_ptr_aligned_delete), outputmemoryPipeline(nullptr, unique_ptr_aligned_delete), inputmemory(nullptr, unique_ptr_aligned_delete);
+std::unique_ptr<char, GPUReconstruction::alignedDefaultBufferDeleter> outputmemory(nullptr, GPUReconstruction::alignedDefaultBufferDeleter()), outputmemoryPipeline(nullptr, GPUReconstruction::alignedDefaultBufferDeleter()), inputmemory(nullptr, GPUReconstruction::alignedDefaultBufferDeleter());
 std::unique_ptr<GPUDisplayFrontendInterface> eventDisplay;
 std::unique_ptr<GPUReconstructionTimeframe> tf;
 int32_t nEventsInDirectory = 0;
@@ -251,20 +247,20 @@ int32_t ReadConfiguration(int argc, char** argv)
 
   if (configStandalone.outputcontrolmem) {
     bool forceEmptyMemory = getenv("LD_PRELOAD") && strstr(getenv("LD_PRELOAD"), "valgrind") != nullptr;
-    outputmemory.reset((char*)::operator new(configStandalone.outputcontrolmem, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)));
+    outputmemory.reset(GPUReconstruction::alignedDefaultBufferAllocator<char>(configStandalone.outputcontrolmem));
     if (forceEmptyMemory) {
       printf("Valgrind detected, emptying GPU output memory to avoid false positive undefined reads");
       memset(outputmemory.get(), 0, configStandalone.outputcontrolmem);
     }
     if (configStandalone.proc.doublePipeline) {
-      outputmemoryPipeline.reset((char*)::operator new(configStandalone.outputcontrolmem, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)));
+      outputmemoryPipeline.reset(GPUReconstruction::alignedDefaultBufferAllocator<char>(configStandalone.outputcontrolmem));
       if (forceEmptyMemory) {
         memset(outputmemoryPipeline.get(), 0, configStandalone.outputcontrolmem);
       }
     }
   }
   if (configStandalone.inputcontrolmem) {
-    inputmemory.reset((char*)::operator new(configStandalone.inputcontrolmem, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)));
+    inputmemory.reset(GPUReconstruction::alignedDefaultBufferAllocator<char>(configStandalone.inputcontrolmem));
   }
 
   configStandalone.proc.showOutputStat = true;

Original file line number	Diff line number	Diff line change
`@@ -22,17 +22,17 @@ namespace o2::gpu`
`22`	`22`
`23`	`23`	`template <typename T, std::size_t MIN_ALIGN = 0>`
`24`	`24`	`struct alignedDeleter {`
`25`		`- void operator()(void* ptr) { ::operator delete(ptr, std::align_val_t(std::max(MIN_ALIGN, alignof(T)))); };`
	`25`	`+ void operator()(void* ptr) { ::operator delete(ptr, std::align_val_t(std::max(MIN_ALIGN, alignof(T)))); }; // TODO: Make this static once we go to C++ 23`
`26`	`26`	`};`
`27`	`27`
`28`	`28`	`template <typename T, std::size_t MIN_ALIGN = 0>`
`29`	`29`	`struct alignedAllocator {`
`30`	`30`	`using value_type = T;`
`31`		`- T* allocate(std::size_t n)`
	`31`	`+ static T* allocate(std::size_t n)`
`32`	`32`	`{`
`33`	`33`	`return (T*)::operator new(n, std::align_val_t(std::max(MIN_ALIGN, alignof(T))));`
`34`	`34`	`}`
`35`		`- void deallocate(T* ptr, std::size_t)`
	`35`	`+ static void deallocate(T* ptr, std::size_t)`
`36`	`36`	`{`
`37`	`37`	`alignedDeleter<T, MIN_ALIGN>()(ptr);`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -467,7 +467,7 @@ int32_t GPUReconstruction::Exit()`
`467`	`467`	`if (mMemoryResources[i].mReuse >= 0) {`
`468`	`468`	`continue;`
`469`	`469`	`}`
`470`		`- ::operator delete(mMemoryResources[i].mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));`
	`470`	`+ alignedDefaultBufferDeleter()(mMemoryResources[i].mPtrDevice);`
`471`	`471`	`mMemoryResources[i].mPtr = mMemoryResources[i].mPtrDevice = nullptr;`
`472`	`472`	`}`
`473`	`473`	`}`
`@@ -630,7 +630,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,`
`630`	`630`	`if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && (control == nullptr \|\| control->useInternal())) {`
`631`	`631`	`if (!(res->mType & GPUMemoryResource::MEMORY_EXTERNAL)) {`
`632`	`632`	`if (res->mPtrDevice && res->mReuse < 0) {`
`633`		`- ::operator delete(res->mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));`
	`633`	`+ alignedDefaultBufferDeleter()(res->mPtrDevice);`
`634`	`634`	`}`
`635`	`635`	`res->mSize = std::max((size_t)res->SetPointers((void*)1) - 1, res->mOverrideSize);`
`636`	`636`	`if (res->mReuse >= 0) {`
`@@ -640,7 +640,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,`
`640`	`640`	`}`
`641`	`641`	`res->mPtrDevice = mMemoryResources[res->mReuse].mPtrDevice;`
`642`	`642`	`} else {`
`643`		`- res->mPtrDevice = ::operator new(res->mSize + constants::GPU_BUFFER_ALIGNMENT, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));`
	`643`	`+ res->mPtrDevice = alignedDefaultBufferAllocator<char>(res->mSize + constants::GPU_BUFFER_ALIGNMENT);`
`644`	`644`	`}`
`645`	`645`	`res->mPtr = GPUProcessor::alignPointer<constants::GPU_BUFFER_ALIGNMENT>(res->mPtrDevice);`
`646`	`646`	`res->SetPointers(res->mPtr);`
`@@ -731,7 +731,7 @@ void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)`
`731`	`731`	`{`
`732`	`732`	`stdspinlock spinlock(mMemoryMutex);`
`733`	`733`	`if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {`
`734`		`- char* retVal = new (std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)) char[size];`
	`734`	`+ char* retVal = alignedDefaultBufferAllocator<char>(size);`
`735`	`735`	`if ((type & GPUMemoryResource::MEMORY_STACK)) {`
`736`	`736`	`mNonPersistentIndividualDirectAllocations.emplace_back(retVal, alignedDefaultBufferDeleter());`
`737`	`737`	`} else {`
`@@ -796,7 +796,7 @@ void* GPUReconstruction::AllocateVolatileMemory(size_t size, bool device)`
`796`	`796`	`if (device) {`
`797`	`797`	`return AllocateVolatileDeviceMemory(size);`
`798`	`798`	`}`
`799`		`- char* retVal = new (std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)) char[size];`
	`799`	`+ char* retVal = alignedDefaultBufferAllocator<char>(size);`
`800`	`800`	`stdspinlock spinlock(mMemoryMutex);`
`801`	`801`	`mVolatileChunks.emplace_back(retVal, alignedDefaultBufferDeleter());`
`802`	`802`	`return retVal;`
`@@ -876,7 +876,7 @@ void GPUReconstruction::FreeRegisteredMemory(GPUMemoryResource* res)`
`876`	`876`	`std::cout << "Freeing " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";`
`877`	`877`	`}`
`878`	`878`	`if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && res->mReuse < 0) {`
`879`		`- ::operator delete(res->mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));`
	`879`	`+ alignedDefaultBufferDeleter()(res->mPtrDevice);`
`880`	`880`	`}`
`881`	`881`	`res->mPtr = nullptr;`
`882`	`882`	`res->mPtrDevice = nullptr;`
`@@ -916,7 +916,7 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag, cons`
`916`	`916`	`std::cout << "Freeing NonPersistent " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";`
`917`	`917`	`}`
`918`	`918`	`if (res->mReuse < 0) {`
`919`		`- ::operator delete(res->mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));`
	`919`	`+ alignedDefaultBufferDeleter()(res->mPtrDevice);`
`920`	`920`	`}`
`921`	`921`	`res->mPtr = nullptr;`
`922`	`922`	`res->mPtrDevice = nullptr;`
Original file line number	Diff line number	Diff line change
`@@ -189,7 +189,7 @@ int32_t GPUReconstructionCPU::InitDevice()`
`189`	`189`	`if (mDeviceMemorySize > mHostMemorySize) {`
`190`	`190`	`mHostMemorySize = mDeviceMemorySize;`
`191`	`191`	`}`
`192`		`- mHostMemoryBase = ::operator new(mHostMemorySize, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));`
	`192`	`+ mHostMemoryBase = alignedDefaultBufferAllocator<char>(mHostMemorySize);`
`193`	`193`	`}`
`194`	`194`	`mHostMemoryPermanent = mHostMemoryBase;`
`195`	`195`	`ClearAllocatedMemory();`
`@@ -205,7 +205,7 @@ int32_t GPUReconstructionCPU::ExitDevice()`
`205`	`205`	`{`
`206`	`206`	`if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {`
`207`	`207`	`if (mMaster == nullptr) {`
`208`		`- ::operator delete(mHostMemoryBase, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));`
	`208`	`+ alignedDefaultBufferDeleter()(mHostMemoryBase);`
`209`	`209`	`}`
`210`	`210`	`mHostMemoryPool = mHostMemoryBase = mHostMemoryPoolEnd = mHostMemoryPermanent = nullptr;`
`211`	`211`	`mHostMemorySize = 0;`