GPU/TPC: Use qTot as marker for HIP clusters instead of qMax (#15481)

fweig · web-flow · commit 8e372de59936 · 2026-06-04T17:07:42.000+02:00
* Use qTot as marker for HIP clusters instead of qMax

* Adjust handling of saturated qTot

* Adjust qTot limit in cluster statistics
diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/ClusterNative.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/ClusterNative.h
@@ -63,8 +63,9 @@ struct ClusterNative {
   static constexpr int scalePadPacked = 64;       //< ~60 is needed for 0.1mm precision, but power of two avoids rounding
   static constexpr int scaleSigmaTimePacked = 32; // 1/32nd of pad/timebin precision for cluster size
   static constexpr int scaleSigmaPadPacked = 32;
-  static constexpr int scaleSaturatedQTot = 4;
-  static constexpr int maxSaturatedQTot = USHRT_MAX * scaleSaturatedQTot;
+  static constexpr int scaleSaturatedQtot = 8;
+  static constexpr int maxRegularQtot = 25 * 1024;
+  static constexpr int maxSaturatedQtot = (USHRT_MAX - maxRegularQtot) * scaleSaturatedQtot;
 
   uint32_t timeFlagsPacked; //< Contains the time in the lower 24 bits in a packed format, contains the flags in the
                             // upper 8 bits
@@ -89,9 +90,8 @@ struct ClusterNative {
   GPUd() uint16_t getQtot() const
   {
     if (isSaturated()) [[unlikely]] {
-      // Check for overflow, so return type can stay uint16
-      auto sqtot = getSaturatedQtot();
-      return sqtot <= USHRT_MAX ? sqtot : USHRT_MAX;
+      auto sQtot = getSaturatedQtot();
+      return sQtot < USHRT_MAX ? sQtot : USHRT_MAX;
     }
     return qTot;
   }
@@ -155,19 +155,19 @@ struct ClusterNative {
     sigmaPadPacked = tmp;
   }
 
-  GPUd() bool isSaturated() const { return qMax >= 1023; }
+  GPUd() bool isSaturated() const { return qTot > maxRegularQtot; }
 
   GPUd() void setSaturatedQtot(uint32_t qtot)
   {
-    if (qtot > maxSaturatedQTot) {
-      qtot = maxSaturatedQTot;
+    this->qTot = USHRT_MAX;
+    if (qtot < maxSaturatedQtot) {
+      this->qTot = ((qtot + scaleSaturatedQtot / 2) / scaleSaturatedQtot) + maxRegularQtot;
     }
-    this->qTot = (qtot + scaleSaturatedQTot / 2) / scaleSaturatedQTot;
   }
 
   GPUd() uint32_t getSaturatedQtot() const
   {
-    return uint32_t(qTot) * scaleSaturatedQTot;
+    return uint32_t(qTot - maxRegularQtot) * scaleSaturatedQtot;
   }
 
   GPUd() void setSaturatedTailLength(uint32_t tail)
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx b/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx
@@ -129,7 +129,7 @@ void GPUTPCClusterStatistics::RunStatistics(const o2::tpc::ClusterNativeAccess*
           if (param.rec.tpc.compressionTypeMask & GPUSettings::CompressionTruncate) {
             GPUTPCCompression::truncateSignificantBitsChargeMax(tmpClusters[k].qMax, param);
             GPUTPCCompression::truncateSignificantBitsWidth(tmpClusters[k].sigmaPadPacked, param);
-            if (!tmpClusters[k].isSaturated()) {
+            if (!tmpClusters[k].isSaturated()) [[likely]] {
               GPUTPCCompression::truncateSignificantBitsCharge(tmpClusters[k].qTot, param);
               GPUTPCCompression::truncateSignificantBitsWidth(tmpClusters[k].sigmaTimePacked, param);
             }
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.h b/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.h
@@ -44,7 +44,7 @@ class GPUTPCClusterStatistics
   bool mDecodingError = false;
 
   static constexpr uint32_t P_MAX_QMAX = GPUTPCCompression::P_MAX_QMAX;
-  static constexpr uint32_t P_MAX_QTOT = GPUTPCCompression::P_MAX_QTOT;
+  static constexpr uint32_t P_MAX_QTOT = GPUTPCCompression::P_MAX_SATURATED_QTOT;
   static constexpr uint32_t P_MAX_TIME = GPUTPCCompression::P_MAX_TIME;
   static constexpr uint32_t P_MAX_PAD = GPUTPCCompression::P_MAX_PAD;
   static constexpr uint32_t P_MAX_SIGMA = GPUTPCCompression::P_MAX_SIGMA;
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.h b/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
@@ -47,14 +47,15 @@ class GPUTPCCompression : public GPUProcessor
 #endif
 
   static constexpr uint32_t P_MAX_QMAX = 1 << 10;
-  static constexpr uint32_t P_MAX_QTOT = 1 << 16;
+  static constexpr uint32_t P_MAX_REGULAR_QTOT = 5 * 5 * P_MAX_QMAX;
+  static constexpr uint32_t P_MAX_SATURATED_QTOT = 1 << 16; // Need two different limits as saturated clusters use full u16 range for qTot
   static constexpr uint32_t P_MAX_TIME = 1 << 24;
   static constexpr uint32_t P_MAX_PAD = 1 << 16;
   static constexpr uint32_t P_MAX_SIGMA = 1 << 8;
   static constexpr uint32_t P_MAX_FLAGS = 1 << 8;
   static constexpr uint32_t P_MAX_QPT = 1 << 8;
 
-  GPUd() static void truncateSignificantBitsCharge(uint16_t& charge, const GPUParam& param) { truncateSignificantBits(charge, param.rec.tpc.sigBitsCharge, P_MAX_QTOT); }
+  GPUd() static void truncateSignificantBitsCharge(uint16_t& charge, const GPUParam& param) { truncateSignificantBits(charge, param.rec.tpc.sigBitsCharge, P_MAX_REGULAR_QTOT); }
   GPUd() static void truncateSignificantBitsChargeMax(uint16_t& charge, const GPUParam& param) { truncateSignificantBits(charge, param.rec.tpc.sigBitsCharge, P_MAX_QMAX); }
   GPUd() static void truncateSignificantBitsWidth(uint8_t& width, const GPUParam& param) { truncateSignificantBits(width, param.rec.tpc.sigBitsWidth, P_MAX_SIGMA); }
 
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -122,7 +122,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
       if (param.rec.tpc.compressionTypeMask & GPUSettings::CompressionTruncate) {
         compressor.truncateSignificantBitsChargeMax(qmax, param);
         compressor.truncateSignificantBitsWidth(sigmapad, param);
-        if (!orgCl.isSaturated()) {
+        if (!orgCl.isSaturated()) [[likely]] {
           compressor.truncateSignificantBitsCharge(qtot, param);
           compressor.truncateSignificantBitsWidth(sigmatime, param);
         }
@@ -301,7 +301,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
         if (param.rec.tpc.compressionTypeMask & GPUSettings::CompressionTruncate) {
           compressor.truncateSignificantBitsChargeMax(qmax, param);
           compressor.truncateSignificantBitsWidth(sigmapad, param);
-          if (!orgCl.isSaturated()) {
+          if (!orgCl.isSaturated()) [[likely]] {
             compressor.truncateSignificantBitsCharge(qtot, param);
             compressor.truncateSignificantBitsWidth(sigmatime, param);
           }

Original file line number	Diff line number	Diff line change
`@@ -63,8 +63,9 @@ struct ClusterNative {`
`63`	`63`	`static constexpr int scalePadPacked = 64; //< ~60 is needed for 0.1mm precision, but power of two avoids rounding`
`64`	`64`	`static constexpr int scaleSigmaTimePacked = 32; // 1/32nd of pad/timebin precision for cluster size`
`65`	`65`	`static constexpr int scaleSigmaPadPacked = 32;`
`66`		`- static constexpr int scaleSaturatedQTot = 4;`
`67`		`- static constexpr int maxSaturatedQTot = USHRT_MAX * scaleSaturatedQTot;`
	`66`	`+ static constexpr int scaleSaturatedQtot = 8;`
	`67`	`+ static constexpr int maxRegularQtot = 25 * 1024;`
	`68`	`+ static constexpr int maxSaturatedQtot = (USHRT_MAX - maxRegularQtot) * scaleSaturatedQtot;`
`68`	`69`
`69`	`70`	`uint32_t timeFlagsPacked; //< Contains the time in the lower 24 bits in a packed format, contains the flags in the`
`70`	`71`	`// upper 8 bits`
`@@ -89,9 +90,8 @@ struct ClusterNative {`
`89`	`90`	`GPUd() uint16_t getQtot() const`
`90`	`91`	`{`
`91`	`92`	`if (isSaturated()) [[unlikely]] {`
`92`		`- // Check for overflow, so return type can stay uint16`
`93`		`- auto sqtot = getSaturatedQtot();`
`94`		`- return sqtot <= USHRT_MAX ? sqtot : USHRT_MAX;`
	`93`	`+ auto sQtot = getSaturatedQtot();`
	`94`	`+ return sQtot < USHRT_MAX ? sQtot : USHRT_MAX;`
`95`	`95`	`}`
`96`	`96`	`return qTot;`
`97`	`97`	`}`
`@@ -155,19 +155,19 @@ struct ClusterNative {`
`155`	`155`	`sigmaPadPacked = tmp;`
`156`	`156`	`}`
`157`	`157`
`158`		`- GPUd() bool isSaturated() const { return qMax >= 1023; }`
	`158`	`+ GPUd() bool isSaturated() const { return qTot > maxRegularQtot; }`
`159`	`159`
`160`	`160`	`GPUd() void setSaturatedQtot(uint32_t qtot)`
`161`	`161`	`{`
`162`		`- if (qtot > maxSaturatedQTot) {`
`163`		`- qtot = maxSaturatedQTot;`
	`162`	`+ this->qTot = USHRT_MAX;`
	`163`	`+ if (qtot < maxSaturatedQtot) {`
	`164`	`+ this->qTot = ((qtot + scaleSaturatedQtot / 2) / scaleSaturatedQtot) + maxRegularQtot;`
`164`	`165`	`}`
`165`		`- this->qTot = (qtot + scaleSaturatedQTot / 2) / scaleSaturatedQTot;`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`GPUd() uint32_t getSaturatedQtot() const`
`169`	`169`	`{`
`170`		`- return uint32_t(qTot) * scaleSaturatedQTot;`
	`170`	`+ return uint32_t(qTot - maxRegularQtot) * scaleSaturatedQtot;`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`GPUd() void setSaturatedTailLength(uint32_t tail)`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ void GPUTPCClusterStatistics::RunStatistics(const o2::tpc::ClusterNativeAccess*`
`129`	`129`	`if (param.rec.tpc.compressionTypeMask & GPUSettings::CompressionTruncate) {`
`130`	`130`	`GPUTPCCompression::truncateSignificantBitsChargeMax(tmpClusters[k].qMax, param);`
`131`	`131`	`GPUTPCCompression::truncateSignificantBitsWidth(tmpClusters[k].sigmaPadPacked, param);`
`132`		`- if (!tmpClusters[k].isSaturated()) {`
	`132`	`+ if (!tmpClusters[k].isSaturated()) [[likely]] {`
`133`	`133`	`GPUTPCCompression::truncateSignificantBitsCharge(tmpClusters[k].qTot, param);`
`134`	`134`	`GPUTPCCompression::truncateSignificantBitsWidth(tmpClusters[k].sigmaTimePacked, param);`
`135`	`135`	`}`