GPU: Some cleanup, and fixes when running only part of processing on GPU

Author: davidrohr

GPU/GPUTracking/Global/GPUChainTracking.cxx

@@ -921,33 +921,6 @@ int32_t GPUChainTracking::FinalizePipelinedProcessing()
   return RunChainFinalize();
 }
 
-int32_t GPUChainTracking::HelperReadEvent(int32_t iSlice, int32_t threadId, GPUReconstructionHelpers::helperParam* par) { return ReadEvent(iSlice, threadId); }
-
-int32_t GPUChainTracking::HelperOutput(int32_t iSlice, int32_t threadId, GPUReconstructionHelpers::helperParam* par)
-{
-  if (param().rec.tpc.globalTracking) {
-    uint32_t tmpSlice = GPUTPCGlobalTracking::GlobalTrackingSliceOrder(iSlice);
-    uint32_t sliceLeft, sliceRight;
-    GPUTPCGlobalTracking::GlobalTrackingSliceLeftRight(tmpSlice, sliceLeft, sliceRight);
-
-    while (mSliceSelectorReady < (int32_t)tmpSlice || mSliceSelectorReady < (int32_t)sliceLeft || mSliceSelectorReady < (int32_t)sliceRight) {
-      if (par->reset) {
-        return 1;
-      }
-    }
-    GlobalTracking(tmpSlice, 0);
-    WriteOutput(tmpSlice, 0);
-  } else {
-    while (mSliceSelectorReady < iSlice) {
-      if (par->reset) {
-        return 1;
-      }
-    }
-    WriteOutput(iSlice, threadId);
-  }
-  return 0;
-}
-
 int32_t GPUChainTracking::CheckErrorCodes(bool cpuOnly, bool forceShowErrors, std::vector<std::array<uint32_t, 4>>* fillErrors)
 {
   int32_t retVal = 0;

GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx

@@ -457,6 +457,7 @@ std::pair<uint32_t, uint32_t> GPUChainTracking::RunTPCClusterizer_transferZS(int
 
 int32_t GPUChainTracking::RunTPCClusterizer_prepare(bool restorePointers)
 {
+  bool doGPU = mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding;
   if (restorePointers) {
     for (uint32_t iSlice = 0; iSlice < NSLICES; iSlice++) {
       processors()->tpcClusterer[iSlice].mPzsOffsets = mCFContext->ptrSave[iSlice].zsOffsetHost;
@@ -512,7 +513,7 @@ int32_t GPUChainTracking::RunTPCClusterizer_prepare(bool restorePointers)
       uint32_t threshold = 40000000;
       uint32_t nDigitsScaled = nDigitsBase > threshold ? nDigitsBase : std::min((threshold + nDigitsBase) / 2, 2 * nDigitsBase);
       processors()->tpcClusterer[iSlice].SetNMaxDigits(processors()->tpcClusterer[iSlice].mPmemory->counters.nDigits, mCFContext->nPagesFragmentMax, nDigitsScaled, mCFContext->nDigitsEndpointMax[iSlice]);
-      if (mRec->IsGPU()) {
+      if (doGPU) {
         processorsShadow()->tpcClusterer[iSlice].SetNMaxDigits(processors()->tpcClusterer[iSlice].mPmemory->counters.nDigits, mCFContext->nPagesFragmentMax, nDigitsScaled, mCFContext->nDigitsEndpointMax[iSlice]);
       }
       if (mPipelineNotifyCtx && GetProcessingSettings().doublePipelineClusterizer) {
@@ -578,7 +579,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
   if (RunTPCClusterizer_prepare(mPipelineNotifyCtx && GetProcessingSettings().doublePipelineClusterizer)) {
     return 1;
   }
-  if (GetProcessingSettings().ompAutoNThreads && !mRec->IsGPU()) {
+  if (GetProcessingSettings().ompAutoNThreads && !doGPU) {
     mRec->SetNOMPThreads(mRec->MemoryScalers()->nTPCdigits / 20000);
   }
 

GPU/GPUTracking/Global/GPUChainTrackingSliceTracker.cxx

@@ -532,3 +532,30 @@ void GPUChainTracking::WriteOutput(int32_t iSlice, int32_t threadId)
     GPUInfo("Finished WriteOutput for slice %d on thread %d\n", iSlice, threadId);
   }
 }
+
+int32_t GPUChainTracking::HelperReadEvent(int32_t iSlice, int32_t threadId, GPUReconstructionHelpers::helperParam* par) { return ReadEvent(iSlice, threadId); }
+
+int32_t GPUChainTracking::HelperOutput(int32_t iSlice, int32_t threadId, GPUReconstructionHelpers::helperParam* par)
+{
+  if (param().rec.tpc.globalTracking) {
+    uint32_t tmpSlice = GPUTPCGlobalTracking::GlobalTrackingSliceOrder(iSlice);
+    uint32_t sliceLeft, sliceRight;
+    GPUTPCGlobalTracking::GlobalTrackingSliceLeftRight(tmpSlice, sliceLeft, sliceRight);
+
+    while (mSliceSelectorReady < (int32_t)tmpSlice || mSliceSelectorReady < (int32_t)sliceLeft || mSliceSelectorReady < (int32_t)sliceRight) {
+      if (par->reset) {
+        return 1;
+      }
+    }
+    GlobalTracking(tmpSlice, 0);
+    WriteOutput(tmpSlice, 0);
+  } else {
+    while (mSliceSelectorReady < iSlice) {
+      if (par->reset) {
+        return 1;
+      }
+    }
+    WriteOutput(iSlice, threadId);
+  }
+  return 0;
+}

GPU/GPUTracking/SliceTracker/GPUTPCSliceData.cxx

@@ -265,22 +265,20 @@ GPUdii() int32_t GPUTPCSliceData::InitFromClusterData(int32_t nBlocks, int32_t n
       for (uint32_t i = iThread; i < NumberOfClusters; i += nThreads) {
         UpdateMinMaxYZ(yMin, yMax, zMin, zMax, YZData[RowOffset + i].x, YZData[RowOffset + i].y);
       }
+    } else if (mem->param.par.earlyTpcTransform) { // Early transform case with ClusterNative present
+      for (uint32_t i = iThread; i < NumberOfClusters; i += nThreads) {
+        float2 tmp;
+        tmp.x = mClusterData[RowOffset + i].y;
+        tmp.y = mClusterData[RowOffset + i].z;
+        UpdateMinMaxYZ(yMin, yMax, zMin, zMax, tmp.x, tmp.y);
+        YZData[RowOffset + i] = tmp;
+      }
     } else {
-      if (mem->param.par.earlyTpcTransform) { // Early transform case with ClusterNative present
-        for (uint32_t i = iThread; i < NumberOfClusters; i += nThreads) {
-          float2 tmp;
-          tmp.x = mClusterData[RowOffset + i].y;
-          tmp.y = mClusterData[RowOffset + i].z;
-          UpdateMinMaxYZ(yMin, yMax, zMin, zMax, tmp.x, tmp.y);
-          YZData[RowOffset + i] = tmp;
-        }
-      } else {
-        for (uint32_t i = iThread; i < NumberOfClusters; i += nThreads) {
-          float x, y, z;
-          GPUTPCConvertImpl::convert(*mem, iSlice, rowIndex, mem->ioPtrs.clustersNative->clusters[iSlice][rowIndex][i].getPad(), mem->ioPtrs.clustersNative->clusters[iSlice][rowIndex][i].getTime(), x, y, z);
-          UpdateMinMaxYZ(yMin, yMax, zMin, zMax, y, z);
-          YZData[RowOffset + i] = CAMath::MakeFloat2(y, z);
-        }
+      for (uint32_t i = iThread; i < NumberOfClusters; i += nThreads) {
+        float x, y, z;
+        GPUTPCConvertImpl::convert(*mem, iSlice, rowIndex, mem->ioPtrs.clustersNative->clusters[iSlice][rowIndex][i].getPad(), mem->ioPtrs.clustersNative->clusters[iSlice][rowIndex][i].getTime(), x, y, z);
+        UpdateMinMaxYZ(yMin, yMax, zMin, zMax, y, z);
+        YZData[RowOffset + i] = CAMath::MakeFloat2(y, z);
       }
     }
 

GPU/GPUTracking/SliceTracker/GPUTPCTracker.cxx

@@ -81,7 +81,7 @@ void* GPUTPCTracker::SetPointersScratch(void* mem)
   if (mRec->GetProcessingSettings().memoryAllocationStrategy != GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
     mem = SetPointersTracklets(mem);
   }
-  if (mRec->IsGPU()) {
+  if (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSliceTracking) {
     computePointerWithAlignment(mem, mTrackletTmpStartHits, GPUCA_ROW_COUNT * mNMaxRowStartHits);
     computePointerWithAlignment(mem, mRowStartHitCountOffset, GPUCA_ROW_COUNT);
   }
@@ -164,7 +164,7 @@ void GPUTPCTracker::SetMaxData(const GPUTrackingInOutPointers& io)
   mNMaxTracks = mRec->MemoryScalers()->NTPCSectorTracks(mData.NumberOfHits());
   mNMaxTrackHits = mRec->MemoryScalers()->NTPCSectorTrackHits(mData.NumberOfHits(), mRec->GetProcessingSettings().tpcInputWithClusterRejection);
 #ifdef GPUCA_SORT_STARTHITS_GPU
-  if (mRec->IsGPU()) {
+  if (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSliceTracking) {
     if (mNMaxStartHits > mNMaxRowStartHits * GPUCA_ROW_COUNT) {
       mNMaxStartHits = mNMaxRowStartHits * GPUCA_ROW_COUNT;
     }