ITS: mm add tests

f3sch · f3sch · commit 824e0b609770 · 2025-09-19T11:24:11.000+02:00
Signed-off-by: Felix Schlepper &lt;felix.schlepper@cern.ch&gt;
diff --git a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
@@ -56,3 +56,5 @@ o2_target_root_dictionary(ITStracking
 if(CUDA_ENABLED OR HIP_ENABLED)
   add_subdirectory(GPU)
 endif()
+
+add_subdirectory(test)
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
@@ -69,7 +69,14 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
     } while (!mUsedMemory.compare_exchange_weak(current_used, new_used,
                                                 std::memory_order_acq_rel,
                                                 std::memory_order_relaxed));
-    return mUpstream->allocate(bytes, alignment);
+    void* p{nullptr};
+    try {
+      p = mUpstream->allocate(bytes, alignment);
+    } catch (...) {
+      mUsedMemory.fetch_sub(bytes, std::memory_order_relaxed);
+      throw;
+    }
+    return p;
   }
 
   void do_deallocate(void* p, size_t bytes, size_t alignment) final
@@ -87,11 +94,12 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
   size_t getMaxMemory() const noexcept { return mMaxMemory; }
   void setMaxMemory(size_t max)
   {
-    if (mUsedMemory > max) {
+    size_t used = mUsedMemory.load(std::memory_order_acquire);
+    if (used > max) {
       ++mCountThrow;
-      throw MemoryLimitExceeded(0, mUsedMemory, max);
+      throw MemoryLimitExceeded(0, used, max);
     }
-    mMaxMemory = max;
+    mMaxMemory.store(max, std::memory_order_release);
   }
 
   void print() const
@@ -106,7 +114,7 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
   }
 
  private:
-  size_t mMaxMemory{std::numeric_limits<size_t>::max()};
+  std::atomic<size_t> mMaxMemory{std::numeric_limits<size_t>::max()};
   std::atomic<size_t> mCountThrow{0};
   std::atomic<size_t> mUsedMemory{0};
   std::pmr::memory_resource* mUpstream;
@@ -116,66 +124,71 @@ template <typename T>
 using bounded_vector = std::pmr::vector<T>;
 
 template <typename T>
-void deepVectorClear(std::vector<T>& vec)
+inline void deepVectorClear(std::vector<T>& vec)
 {
   std::vector<T>().swap(vec);
 }
 
 template <typename T>
-inline void deepVectorClear(bounded_vector<T>& vec, BoundedMemoryResource* bmr = nullptr)
+inline void deepVectorClear(bounded_vector<T>& vec, std::pmr::memory_resource* mr = nullptr)
 {
-  vec.~bounded_vector<T>();
-  if (bmr == nullptr) {
-    auto alloc = vec.get_allocator().resource();
-    new (&vec) bounded_vector<T>(alloc);
+  auto* res = mr ? mr : vec.get_allocator().resource();
+  if (res == vec.get_allocator().resource()) {
+    bounded_vector<T> empty{std::pmr::polymorphic_allocator<T>{res}};
+    vec.swap(empty);
   } else {
-    new (&vec) bounded_vector<T>(bmr);
+    vec = bounded_vector<T>(std::pmr::polymorphic_allocator<T>{res});
   }
 }
 
 template <typename T>
-void deepVectorClear(std::vector<bounded_vector<T>>& vec, BoundedMemoryResource* bmr = nullptr)
+inline void deepVectorClear(std::vector<bounded_vector<T>>& vec, std::pmr::memory_resource* mr = nullptr)
 {
   for (auto& v : vec) {
-    deepVectorClear(v, bmr);
+    deepVectorClear(v, mr);
   }
 }
 
 template <typename T, size_t S>
-void deepVectorClear(std::array<bounded_vector<T>, S>& arr, BoundedMemoryResource* bmr = nullptr)
+inline void deepVectorClear(std::array<bounded_vector<T>, S>& arr, std::pmr::memory_resource* mr = nullptr)
 {
   for (size_t i{0}; i < S; ++i) {
-    deepVectorClear(arr[i], bmr);
+    deepVectorClear(arr[i], mr);
   }
 }
 
 template <typename T>
-void clearResizeBoundedVector(bounded_vector<T>& vec, size_t size, BoundedMemoryResource* bmr, T def = T())
+inline void clearResizeBoundedVector(bounded_vector<T>& vec, size_t sz, std::pmr::memory_resource* mr = nullptr, T def = T())
 {
-  vec.~bounded_vector<T>();
-  new (&vec) bounded_vector<T>(size, def, bmr);
+  auto* res = mr ? mr : vec.get_allocator().resource();
+  if (res == vec.get_allocator().resource()) {
+    bounded_vector<T> tmp(sz, def, std::pmr::polymorphic_allocator<T>{res});
+    vec.swap(tmp);
+  } else {
+    vec = bounded_vector<T>(sz, def, std::pmr::polymorphic_allocator<T>{res});
+  }
 }
 
 template <typename T>
-void clearResizeBoundedVector(std::vector<bounded_vector<T>>& vec, size_t size, BoundedMemoryResource* bmr)
+void clearResizeBoundedVector(std::vector<bounded_vector<T>>& vec, size_t size, std::pmr::memory_resource* mr)
 {
   vec.clear();
   vec.reserve(size);
-  for (size_t i{0}; i < size; ++i) {
-    vec.emplace_back(bmr);
+  for (size_t i = 0; i < size; ++i) {
+    vec.emplace_back(std::pmr::polymorphic_allocator<bounded_vector<T>>{mr});
   }
 }
 
 template <typename T, size_t S>
-void clearResizeBoundedArray(std::array<bounded_vector<T>, S>& arr, size_t size, BoundedMemoryResource* bmr, T def = T())
+inline void clearResizeBoundedArray(std::array<bounded_vector<T>, S>& arr, size_t size, std::pmr::memory_resource* mr = nullptr, T def = T())
 {
   for (size_t i{0}; i < S; ++i) {
-    clearResizeBoundedVector(arr[i], size, bmr, def);
+    clearResizeBoundedVector(arr[i], size, mr, def);
   }
 }
 
 template <typename T>
-std::vector<T> toSTDVector(const bounded_vector<T>& b)
+inline std::vector<T> toSTDVector(const bounded_vector<T>& b)
 {
   std::vector<T> t(b.size());
   std::copy(b.cbegin(), b.cend(), t.begin());
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -188,7 +188,7 @@ struct TimeFrame {
   auto getNumberOfUsedExtendedClusters() const { return mNExtendedUsedClusters; }
 
   /// memory management
-  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool);
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool);
   auto& getMemoryPool() const noexcept { return mMemoryPool; }
   bool checkMemory(unsigned long max) { return getArtefactsMemory() < max; }
   unsigned long getArtefactsMemory() const;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -66,7 +66,7 @@ class Tracker
     const LogFunc& = [](const std::string& s) { std::cerr << s << '\n'; });
 
   void setParameters(const std::vector<TrackingParameters>& p) { mTrkParams = p; }
-  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) { mMemoryPool = pool; }
   std::vector<TrackingParameters>& getParameters() { return mTrkParams; }
   void setBz(float bz) { mTraits->setBz(bz); }
   bool isMatLUT() const { return mTraits->isMatLUT(); }
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -70,7 +70,7 @@ class TrackerTraits
   bool isMatLUT() const;
   virtual const char* getName() const noexcept { return "CPU"; }
   virtual bool isGPU() const noexcept { return false; }
-  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) noexcept { mMemoryPool = pool; }
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) noexcept { mMemoryPool = pool; }
   auto getMemoryPool() const noexcept { return mMemoryPool; }
 
   // Others
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -52,7 +52,7 @@ class Vertexer
   auto& getVertParameters() const { return mTraits->getVertexingParameters(); }
   void setParameters(const std::vector<VertexingParameters>& vertParams) { mVertParams = vertParams; }
   const auto& getParameters() const noexcept { return mVertParams; }
-  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) { mMemoryPool = pool; }
 
   std::vector<Vertex> exportVertices();
   VertexerTraitsN* getTraits() const { return mTraits; };
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -82,7 +82,7 @@ class VertexerTraits
   virtual bool isGPU() const noexcept { return false; }
   virtual const char* getName() const noexcept { return "CPU"; }
   virtual bool usesMemoryPool() const noexcept { return true; }
-  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) { mMemoryPool = pool; }
 
   static std::pair<o2::MCCompLabel, float> computeMain(const bounded_vector<o2::MCCompLabel>& elements)
   {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -575,36 +575,32 @@ void TimeFrame<nLayers>::printSliceInfo(const int startROF, const int sliceSize)
     LOG(info) << "Number of seeding vertices: " << getPrimaryVertices(iROF).size();
     int iVertex{0};
     for (auto& v : getPrimaryVertices(iROF)) {
-      LOG(info) << "\t vertex " << iVertex++ << ": x=" << v.getX() << " " << " y=" << v.getY() << " z=" << v.getZ() << " has " << v.getNContributors() << " contributors.";
+      LOG(info) << "\t vertex " << iVertex++ << ": x=" << v.getX() << " "
+                << " y=" << v.getY() << " z=" << v.getZ() << " has " << v.getNContributors() << " contributors.";
     }
   }
 }
 
 template <int nLayers>
-void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool)
+void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
 {
   mMemoryPool = pool;
 
-  auto initVector = [&]<typename T>(bounded_vector<T>& vec) {
-    auto alloc = vec.get_allocator().resource();
-    if (alloc != mMemoryPool.get()) {
-      vec = bounded_vector<T>(mMemoryPool.get());
-    }
+  auto initVector = [&]<typename T>(bounded_vector<T> & vec)
+  {
+    bounded_vector<T> tmp(std::pmr::polymorphic_allocator<T>{mMemoryPool.get()});
+    vec.swap(tmp);
   };
-  auto initArrays = [&]<typename T, size_t S>(std::array<bounded_vector<T>, S>& arr) {
+  auto initArrays = [&]<typename T, size_t S>(std::array<bounded_vector<T>, S> & arr)
+  {
     for (size_t i{0}; i < S; ++i) {
-      auto alloc = arr[i].get_allocator().resource();
-      if (alloc != mMemoryPool.get()) {
-        arr[i] = bounded_vector<T>(mMemoryPool.get());
-      }
+      initVector(arr[i]);
     }
   };
-  auto initVectors = [&]<typename T>(std::vector<bounded_vector<T>>& vec) {
+  auto initVectors = [&]<typename T>(std::vector<bounded_vector<T>> & vec)
+  {
     for (size_t i{0}; i < vec.size(); ++i) {
-      auto alloc = vec[i].get_allocator().resource();
-      if (alloc != mMemoryPool.get()) {
-        vec[i] = bounded_vector<T>(mMemoryPool.get());
-      }
+      initVector(vec[i]);
     }
   };
 
diff --git a/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt
@@ -0,0 +1,16 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_test(boundedmemoryresource
+            SOURCES testBoundedMemoryResource.cxx
+            COMPONENT_NAME its-tracking
+            LABELS "its;tracking"
+            PUBLIC_LINK_LIBRARIES O2::ITStracking)
diff --git a/Detectors/ITSMFT/ITS/tracking/test/testBoundedMemoryResource.cxx b/Detectors/ITSMFT/ITS/tracking/test/testBoundedMemoryResource.cxx

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,14 @@ class BoundedMemoryResource final : public std::pmr::memory_resource`
`69`	`69`	`} while (!mUsedMemory.compare_exchange_weak(current_used, new_used,`
`70`	`70`	`std::memory_order_acq_rel,`
`71`	`71`	`std::memory_order_relaxed));`
`72`		`- return mUpstream->allocate(bytes, alignment);`
	`72`	`+ void* p{nullptr};`
	`73`	`+ try {`
	`74`	`+ p = mUpstream->allocate(bytes, alignment);`
	`75`	`+ } catch (...) {`
	`76`	`+ mUsedMemory.fetch_sub(bytes, std::memory_order_relaxed);`
	`77`	`+ throw;`
	`78`	`+ }`
	`79`	`+ return p;`
`73`	`80`	`}`
`74`	`81`
`75`	`82`	`void do_deallocate(void* p, size_t bytes, size_t alignment) final`
`@@ -87,11 +94,12 @@ class BoundedMemoryResource final : public std::pmr::memory_resource`
`87`	`94`	`size_t getMaxMemory() const noexcept { return mMaxMemory; }`
`88`	`95`	`void setMaxMemory(size_t max)`
`89`	`96`	`{`
`90`		`- if (mUsedMemory > max) {`
	`97`	`+ size_t used = mUsedMemory.load(std::memory_order_acquire);`
	`98`	`+ if (used > max) {`
`91`	`99`	`++mCountThrow;`
`92`		`- throw MemoryLimitExceeded(0, mUsedMemory, max);`
	`100`	`+ throw MemoryLimitExceeded(0, used, max);`
`93`	`101`	`}`
`94`		`- mMaxMemory = max;`
	`102`	`+ mMaxMemory.store(max, std::memory_order_release);`
`95`	`103`	`}`
`96`	`104`
`97`	`105`	`void print() const`
`@@ -106,7 +114,7 @@ class BoundedMemoryResource final : public std::pmr::memory_resource`
`106`	`114`	`}`
`107`	`115`
`108`	`116`	`private:`
`109`		`- size_t mMaxMemory{std::numeric_limits<size_t>::max()};`
	`117`	`+ std::atomic<size_t> mMaxMemory{std::numeric_limits<size_t>::max()};`
`110`	`118`	`std::atomic<size_t> mCountThrow{0};`
`111`	`119`	`std::atomic<size_t> mUsedMemory{0};`
`112`	`120`	`std::pmr::memory_resource* mUpstream;`
`@@ -116,66 +124,71 @@ template <typename T>`
`116`	`124`	`using bounded_vector = std::pmr::vector<T>;`
`117`	`125`
`118`	`126`	`template <typename T>`
`119`		`-void deepVectorClear(std::vector<T>& vec)`
	`127`	`+inline void deepVectorClear(std::vector<T>& vec)`
`120`	`128`	`{`
`121`	`129`	`std::vector<T>().swap(vec);`
`122`	`130`	`}`
`123`	`131`
`124`	`132`	`template <typename T>`
`125`		`-inline void deepVectorClear(bounded_vector<T>& vec, BoundedMemoryResource* bmr = nullptr)`
	`133`	`+inline void deepVectorClear(bounded_vector<T>& vec, std::pmr::memory_resource* mr = nullptr)`
`126`	`134`	`{`
`127`		`- vec.~bounded_vector<T>();`
`128`		`- if (bmr == nullptr) {`
`129`		`- auto alloc = vec.get_allocator().resource();`
`130`		`- new (&vec) bounded_vector<T>(alloc);`
	`135`	`+ auto* res = mr ? mr : vec.get_allocator().resource();`
	`136`	`+ if (res == vec.get_allocator().resource()) {`
	`137`	`+ bounded_vector<T> empty{std::pmr::polymorphic_allocator<T>{res}};`
	`138`	`+ vec.swap(empty);`
`131`	`139`	`} else {`
`132`		`- new (&vec) bounded_vector<T>(bmr);`
	`140`	`+ vec = bounded_vector<T>(std::pmr::polymorphic_allocator<T>{res});`
`133`	`141`	`}`
`134`	`142`	`}`
`135`	`143`
`136`	`144`	`template <typename T>`
`137`		`-void deepVectorClear(std::vector<bounded_vector<T>>& vec, BoundedMemoryResource* bmr = nullptr)`
	`145`	`+inline void deepVectorClear(std::vector<bounded_vector<T>>& vec, std::pmr::memory_resource* mr = nullptr)`
`138`	`146`	`{`
`139`	`147`	`for (auto& v : vec) {`
`140`		`- deepVectorClear(v, bmr);`
	`148`	`+ deepVectorClear(v, mr);`
`141`	`149`	`}`
`142`	`150`	`}`
`143`	`151`
`144`	`152`	`template <typename T, size_t S>`
`145`		`-void deepVectorClear(std::array<bounded_vector<T>, S>& arr, BoundedMemoryResource* bmr = nullptr)`
	`153`	`+inline void deepVectorClear(std::array<bounded_vector<T>, S>& arr, std::pmr::memory_resource* mr = nullptr)`
`146`	`154`	`{`
`147`	`155`	`for (size_t i{0}; i < S; ++i) {`
`148`		`- deepVectorClear(arr[i], bmr);`
	`156`	`+ deepVectorClear(arr[i], mr);`
`149`	`157`	`}`
`150`	`158`	`}`
`151`	`159`
`152`	`160`	`template <typename T>`
`153`		`-void clearResizeBoundedVector(bounded_vector<T>& vec, size_t size, BoundedMemoryResource* bmr, T def = T())`
	`161`	`+inline void clearResizeBoundedVector(bounded_vector<T>& vec, size_t sz, std::pmr::memory_resource* mr = nullptr, T def = T())`
`154`	`162`	`{`
`155`		`- vec.~bounded_vector<T>();`
`156`		`- new (&vec) bounded_vector<T>(size, def, bmr);`
	`163`	`+ auto* res = mr ? mr : vec.get_allocator().resource();`
	`164`	`+ if (res == vec.get_allocator().resource()) {`
	`165`	`+ bounded_vector<T> tmp(sz, def, std::pmr::polymorphic_allocator<T>{res});`
	`166`	`+ vec.swap(tmp);`
	`167`	`+ } else {`
	`168`	`+ vec = bounded_vector<T>(sz, def, std::pmr::polymorphic_allocator<T>{res});`
	`169`	`+ }`
`157`	`170`	`}`
`158`	`171`
`159`	`172`	`template <typename T>`
`160`		`-void clearResizeBoundedVector(std::vector<bounded_vector<T>>& vec, size_t size, BoundedMemoryResource* bmr)`
	`173`	`+void clearResizeBoundedVector(std::vector<bounded_vector<T>>& vec, size_t size, std::pmr::memory_resource* mr)`
`161`	`174`	`{`
`162`	`175`	`vec.clear();`
`163`	`176`	`vec.reserve(size);`
`164`		`- for (size_t i{0}; i < size; ++i) {`
`165`		`- vec.emplace_back(bmr);`
	`177`	`+ for (size_t i = 0; i < size; ++i) {`
	`178`	`+ vec.emplace_back(std::pmr::polymorphic_allocator<bounded_vector<T>>{mr});`
`166`	`179`	`}`
`167`	`180`	`}`
`168`	`181`
`169`	`182`	`template <typename T, size_t S>`
`170`		`-void clearResizeBoundedArray(std::array<bounded_vector<T>, S>& arr, size_t size, BoundedMemoryResource* bmr, T def = T())`
	`183`	`+inline void clearResizeBoundedArray(std::array<bounded_vector<T>, S>& arr, size_t size, std::pmr::memory_resource* mr = nullptr, T def = T())`
`171`	`184`	`{`
`172`	`185`	`for (size_t i{0}; i < S; ++i) {`
`173`		`- clearResizeBoundedVector(arr[i], size, bmr, def);`
	`186`	`+ clearResizeBoundedVector(arr[i], size, mr, def);`
`174`	`187`	`}`
`175`	`188`	`}`
`176`	`189`
`177`	`190`	`template <typename T>`
`178`		`-std::vector<T> toSTDVector(const bounded_vector<T>& b)`
	`191`	`+inline std::vector<T> toSTDVector(const bounded_vector<T>& b)`
`179`	`192`	`{`
`180`	`193`	`std::vector<T> t(b.size());`
`181`	`194`	`std::copy(b.cbegin(), b.cend(), t.begin());`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ class VertexerTraits`
`82`	`82`	`virtual bool isGPU() const noexcept { return false; }`
`83`	`83`	`virtual const char* getName() const noexcept { return "CPU"; }`
`84`	`84`	`virtual bool usesMemoryPool() const noexcept { return true; }`
`85`		`- void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }`
	`85`	`+ void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) { mMemoryPool = pool; }`
`86`	`86`
`87`	`87`	`static std::pair<o2::MCCompLabel, float> computeMain(const bounded_vector<o2::MCCompLabel>& elements)`
`88`	`88`	`{`