Use internal reference counting in CaloCellGeometry

This removes the need for std::shared_ptr in PFRecHit and should
reduce memory usage.

Author: Dr15Jones

DataFormats/ParticleFlowReco/interface/PFRecHit.h

@@ -17,6 +17,7 @@
 #include "DataFormats/Common/interface/RefToBase.h"
 
 #include "Geometry/CaloGeometry/interface/CaloCellGeometry.h"
+#include "Geometry/CaloGeometry/interface/CaloCellGeometryMayOwnPtr.h"
 
 namespace reco {
 
@@ -50,11 +51,8 @@ namespace reco {
     /// default constructor. Sets energy and position to zero
     PFRecHit() {}
 
-    PFRecHit(std::shared_ptr<const CaloCellGeometry> caloCell,
-             unsigned int detId,
-             PFLayer::Layer layer,
-             float energy,
-             uint32_t flags = 0)
+    PFRecHit(
+        CaloCellGeometryMayOwnPtr caloCell, unsigned int detId, PFLayer::Layer layer, float energy, uint32_t flags = 0)
         : caloCell_(std::move(caloCell)), detId_(detId), layer_(layer), energy_(energy), flags_(flags) {}
 
     /// copy
@@ -139,7 +137,7 @@ namespace reco {
     Neighbours buildNeighbours(unsigned int n) const { return Neighbours(neighbours_.data(), n); }
 
     /// cell geometry
-    std::shared_ptr<const CaloCellGeometry> caloCell_ = nullptr;
+    CaloCellGeometryMayOwnPtr caloCell_;
 
     ///cell detid
     unsigned int detId_ = 0;

Geometry/CaloGeometry/interface/CaloCellGeometry.h

@@ -12,6 +12,7 @@
 #include <array>
 #include <string>
 #include <cassert>
+#include <atomic>
 
 /** \class CaloCellGeometry
 
@@ -61,6 +62,8 @@ class CaloCellGeometry {
   typedef std::vector<ParVec> ParVecVec;
   typedef EZMgrFL<CCGFloat> ParMgr;
 
+  friend class CaloCellGeometryMayOwnPtr;
+
   static constexpr unsigned int k_cornerSize = 8;
 
   using RepCorners = std::array<RhoEtaPhi, k_cornerSize>;
@@ -114,8 +117,12 @@ class CaloCellGeometry {
 
   CaloCellGeometry(const CornersVec& cv, const CCGFloat* par);
 
-  CaloCellGeometry(void);
+  CaloCellGeometry();
 
+  CaloCellGeometry(CaloCellGeometry&&) = default;
+  CaloCellGeometry(CaloCellGeometry const&) = default;
+  CaloCellGeometry& operator=(CaloCellGeometry&&) = default;
+  CaloCellGeometry& operator=(CaloCellGeometry const&) = default;
   // MUST be called by children constructors
   void initSpan() {
     initCorners(m_corners);
@@ -146,6 +153,10 @@ class CaloCellGeometry {
       m_repCorners[i] = {getCorners()[i].perp(), getCorners()[i].eta(), getCorners()[i].barePhi()};
   }
 
+  //These methods are ONLY used by CaloCellGeometryMayOwnPtr
+  void increment() const { ++m_ref.m_count; }
+  bool decrement() const { return 0 == --m_ref.m_count; }
+
   GlobalPoint m_refPoint;
   GlobalPoint m_backPoint;
   CornersVec m_corners;
@@ -154,6 +165,15 @@ class CaloCellGeometry {
   float m_dEta;
   float m_dPhi;
   std::array<RhoEtaPhi, k_cornerSize> m_repCorners;
+  struct RefCount {
+    RefCount() = default;
+    RefCount(RefCount&&) {}
+    RefCount(RefCount const&) {}
+    RefCount& operator=(RefCount&&) { return *this; }
+    RefCount& operator=(const RefCount&) { return *this; }
+
+    mutable std::atomic<unsigned int> m_count = 0;
+  } m_ref;
 };
 
 std::ostream& operator<<(std::ostream& s, const CaloCellGeometry& cell);

Geometry/CaloGeometry/interface/CaloCellGeometryMayOwnPtr.h

@@ -29,31 +29,50 @@
 
 class CaloCellGeometryMayOwnPtr {
 public:
-  explicit CaloCellGeometryMayOwnPtr(CaloCellGeometry const* iPtr, bool iOwn) noexcept : ptr_{iPtr}, own_{iOwn} {}
   explicit CaloCellGeometryMayOwnPtr(std::unique_ptr<CaloCellGeometry const> iPtr) noexcept
-      : ptr_{iPtr.release()}, own_{true} {}
+      : ptr_{iPtr.release()}, own_{ptr_ != nullptr} {
+    if (own_) {
+      ptr_->increment();
+    }
+  }
   explicit CaloCellGeometryMayOwnPtr(CaloCellGeometryPtr const& iPtr) noexcept : ptr_{iPtr.get()}, own_{false} {}
 
   ~CaloCellGeometryMayOwnPtr() noexcept {
-    if (own_) {
+    if (own_ and ptr_->decrement()) {
       delete ptr_;
     }
   }
   CaloCellGeometryMayOwnPtr() noexcept = default;
-  CaloCellGeometryMayOwnPtr(const CaloCellGeometryMayOwnPtr&) noexcept = delete;
+  CaloCellGeometryMayOwnPtr(const CaloCellGeometryMayOwnPtr& iPtr) noexcept : ptr_{iPtr.ptr_}, own_{iPtr.own_} {
+    if (own_) {
+      ptr_->increment();
+    }
+  }
   CaloCellGeometryMayOwnPtr(CaloCellGeometryMayOwnPtr&& iPtr) noexcept : ptr_{iPtr.ptr_}, own_{iPtr.own_} {
     iPtr.ptr_ = nullptr;
     iPtr.own_ = false;
   }
-  CaloCellGeometryMayOwnPtr& operator=(CaloCellGeometryMayOwnPtr const&) noexcept = delete;
-  CaloCellGeometryMayOwnPtr& operator=(CaloCellGeometryMayOwnPtr&& iPtr) noexcept {
+  CaloCellGeometryMayOwnPtr& operator=(CaloCellGeometryMayOwnPtr const& iPtr) noexcept {
+    //Even if someone does `foo = foo` this will work
+    auto tmpPtr = iPtr.ptr_;
+    auto tmpOwn = iPtr.own_;
+    CaloCellGeometryMayOwnPtr temp(std::move(*this));
+    ptr_ = tmpPtr;
+    own_ = tmpOwn;
     if (own_) {
-      delete ptr_;
+      ptr_->increment();
+    }
+    return *this;
+  }
+  CaloCellGeometryMayOwnPtr& operator=(CaloCellGeometryMayOwnPtr&& iPtr) noexcept {
+    if (&iPtr != this) {
+      CaloCellGeometryMayOwnPtr temp(std::move(*this));
+
+      ptr_ = iPtr.ptr_;
+      own_ = iPtr.own_;
+      iPtr.ptr_ = nullptr;
+      iPtr.own_ = false;
     }
-    ptr_ = iPtr.ptr_;
-    own_ = iPtr.own_;
-    iPtr.ptr_ = nullptr;
-    iPtr.own_ = false;
     return *this;
   }
 
@@ -63,17 +82,6 @@ class CaloCellGeometryMayOwnPtr {
 
   operator CaloCellGeometry const*() const { return ptr_; }
 
-  //transfers ownership to a shared_ptr
-  std::shared_ptr<CaloCellGeometry const> releaseToShared() {
-    auto p = ptr_;
-    ptr_ = nullptr;
-    if (own_) {
-      own_ = false;
-      return std::shared_ptr<CaloCellGeometry const>(p);
-    }
-    return std::shared_ptr<CaloCellGeometry const>(p, no_delete());
-  }
-
 private:
   struct no_delete {
     void operator()(const void*) {}

Geometry/CaloGeometry/interface/IdealZPrism.h

@@ -57,12 +57,8 @@ class IdealZPrism final : public CaloCellGeometry {
 
   void vocalCorners(Pt3DVec& vec, const CCGFloat* pv, Pt3D& ref) const override;
 
-  // corrected geom for PF
-  std::shared_ptr<const IdealZPrism> forPF() const {
-    static const auto do_not_delete = [](const void*) {};
-    auto cell = std::shared_ptr<const IdealZPrism>(m_geoForPF.get(), do_not_delete);
-    return cell;
-  }
+  // corrected geom for PF. memory is owned by this object and not transfered to caller.
+  const IdealZPrism* forPF() const { return m_geoForPF.get(); }
 
 private:
   void initCorners(CornersVec&) override;