Make the the size of the binner (HistoContainer) settable at run time. The total number of Pixel Clusters is not a limit anymore on GPU

CUDADataFormats/SiPixelCluster/interface/gpuClusteringConstants.h

@@ -4,17 +4,6 @@
 #include <cstdint>
 #include <limits>
 
-namespace pixelGPUConstants {
-#ifdef GPU_SMALL_EVENTS
-  // kept for testing and debugging
-  constexpr uint32_t maxNumberOfHits = 24 * 1024;
-#else
-  // data at pileup 50 has 18300 +/- 3500 hits; 40000 is around 6 sigma away
-  // tested on MC events with 55-75 pileup events
-  constexpr uint32_t maxNumberOfHits = 48 * 1024;
-#endif
-}  // namespace pixelGPUConstants
-
 namespace gpuClustering {
 #ifdef GPU_SMALL_EVENTS
   // kept for testing and debugging
@@ -28,7 +17,6 @@ namespace gpuClustering {
 
   constexpr uint16_t maxNumModules = 2000;
   constexpr int32_t maxNumClustersPerModules = maxHitsInModule();
-  constexpr uint32_t maxNumClusters = pixelGPUConstants::maxNumberOfHits;
   constexpr uint16_t invalidModuleId = std::numeric_limits<uint16_t>::max() - 1;
   static_assert(invalidModuleId > maxNumModules);  // invalidModuleId must be > maxNumModules
 

CUDADataFormats/Track/interface/TrackSoAHeterogeneousT.h

@@ -17,7 +17,7 @@ class TrackSoAHeterogeneousT {
 
   using Quality = pixelTrack::Quality;
   using hindex_type = uint32_t;
-  using HitContainer = cms::cuda::OneToManyAssoc<hindex_type, S, 5 * S>;
+  using HitContainer = cms::cuda::OneToManyAssoc<hindex_type, S + 1, 5 * S>;
 
   // Always check quality is at least loose!
   // CUDA does not support enums  in __lgc ...

CUDADataFormats/TrackingRecHit/interface/TrackingRecHit2DHeterogeneous.h

@@ -34,6 +34,7 @@ class TrackingRecHit2DHeterogeneous {
   auto hitsModuleStart() const { return m_hitsModuleStart; }
   auto hitsLayerStart() { return m_hitsLayerStart; }
   auto phiBinner() { return m_phiBinner; }
+  auto phiBinnerStorage() { return m_phiBinnerStorage; }
   auto iphi() { return m_iphi; }
 
   // only the local coord and detector index
@@ -42,7 +43,7 @@ class TrackingRecHit2DHeterogeneous {
 
 private:
   static constexpr uint32_t n16 = 4;                 // number of elements in m_store16
-  static constexpr uint32_t n32 = 9;                 // number of elements in m_store32
+  static constexpr uint32_t n32 = 10;                // number of elements in m_store32
   static_assert(sizeof(uint32_t) == sizeof(float));  // just stating the obvious
 
   unique_ptr<uint16_t[]> m_store16;  //!
@@ -59,6 +60,7 @@ class TrackingRecHit2DHeterogeneous {
 
   // needed as kernel params...
   PhiBinner* m_phiBinner;
+  PhiBinner::index_type* m_phiBinnerStorage;
   uint32_t* m_hitsLayerStart;
   int16_t* m_iphi;
 };
@@ -97,14 +99,20 @@ TrackingRecHit2DHeterogeneous<Traits>::TrackingRecHit2DHeterogeneous(uint32_t nH
   // this will break 1to1 correspondence with cluster and module locality
   // so unless proven VERY inefficient we keep it ordered as generated
   m_store16 = Traits::template make_device_unique<uint16_t[]>(nHits * n16, stream);
-  m_store32 = Traits::template make_device_unique<float[]>(nHits * n32 + 11, stream);
+  m_store32 =
+      Traits::template make_device_unique<float[]>(nHits * n32 + phase1PixelTopology::numberOfLayers + 1, stream);
   m_PhiBinnerStore = Traits::template make_device_unique<TrackingRecHit2DSOAView::PhiBinner>(stream);
 
+  static_assert(sizeof(TrackingRecHit2DSOAView::hindex_type) == sizeof(float));
+  static_assert(sizeof(TrackingRecHit2DSOAView::hindex_type) == sizeof(TrackingRecHit2DSOAView::PhiBinner::index_type));
+
   auto get16 = [&](int i) { return m_store16.get() + i * nHits; };
   auto get32 = [&](int i) { return m_store32.get() + i * nHits; };
 
   // copy all the pointers
   m_phiBinner = view->m_phiBinner = m_PhiBinnerStore.get();
+  m_phiBinnerStorage = view->m_phiBinnerStorage =
+      reinterpret_cast<TrackingRecHit2DSOAView::PhiBinner::index_type*>(get32(9));
 
   view->m_xl = get32(0);
   view->m_yl = get32(1);

CUDADataFormats/TrackingRecHit/interface/TrackingRecHit2DSOAView.h

@@ -14,11 +14,9 @@ namespace pixelCPEforGPU {
 
 class TrackingRecHit2DSOAView {
 public:
-  static constexpr uint32_t maxHits() { return gpuClustering::maxNumClusters; }
   using hindex_type = uint32_t;  // if above is <=2^32
 
-  using PhiBinner =
-      cms::cuda::HistoContainer<int16_t, 128, gpuClustering::maxNumClusters, 8 * sizeof(int16_t), hindex_type, 10>;
+  using PhiBinner = cms::cuda::HistoContainer<int16_t, 128, -1, 8 * sizeof(int16_t), hindex_type, 10>;
 
   using AverageGeometry = phase1PixelTopology::AverageGeometry;
 
@@ -95,6 +93,7 @@ class TrackingRecHit2DSOAView {
   uint32_t* m_hitsLayerStart;
 
   PhiBinner* m_phiBinner;
+  PhiBinner::index_type* m_phiBinnerStorage;
 
   uint32_t m_nHits;
 };

HeterogeneousCore/CUDAUtilities/interface/FlexiStorage.h

@@ -0,0 +1,49 @@
+#ifndef HeterogeneousCore_CUDAUtilities_interface_FlexiStorage_h
+#define HeterogeneousCore_CUDAUtilities_interface_FlexiStorage_h
+
+#include <cstdint>
+
+namespace cms {
+  namespace cuda {
+
+    template <typename I, int S>
+    class FlexiStorage {
+    public:
+      constexpr int capacity() const { return S; }
+
+      constexpr I& operator[](int i) { return m_v[i]; }
+      constexpr const I& operator[](int i) const { return m_v[i]; }
+
+      constexpr I* data() { return m_v; }
+      constexpr I const* data() const { return m_v; }
+
+    private:
+      I m_v[S];
+    };
+
+    template <typename I>
+    class FlexiStorage<I, -1> {
+    public:
+      constexpr void init(I* v, int s) {
+        m_v = v;
+        m_capacity = s;
+      }
+
+      constexpr int capacity() const { return m_capacity; }
+
+      constexpr I& operator[](int i) { return m_v[i]; }
+      constexpr const I& operator[](int i) const { return m_v[i]; }
+
+      constexpr I* data() { return m_v; }
+      constexpr I const* data() const { return m_v; }
+
+    private:
+      I* m_v;
+      int m_capacity;
+    };
+
+  }  // namespace cuda
+
+}  // namespace cms
+
+#endif