GPU: Fix RecordMarker must operate on reference, since OpenCL will change the event pointer

davidrohr · davidrohr · commit 3f5b83ecec04 · 2024-11-16T13:17:51.000+01:00
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -114,7 +114,7 @@ class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCP
   virtual void SynchronizeEvents(deviceEvent* evList, int32_t nEvents = 1) {}
   virtual void StreamWaitForEvents(int32_t stream, deviceEvent* evList, int32_t nEvents = 1) {}
   virtual bool IsEventDone(deviceEvent* evList, int32_t nEvents = 1) { return true; }
-  virtual void RecordMarker(deviceEvent ev, int32_t stream) {}
+  virtual void RecordMarker(deviceEvent* ev, int32_t stream) {}
   virtual void SynchronizeGPU() {}
   virtual void ReleaseEvent(deviceEvent ev) {}
   virtual int32_t StartHelperThreads() { return 0; }
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -548,7 +548,7 @@ size_t GPUReconstructionCUDA::WriteToConstantMemory(size_t offset, const void* s
 }
 
 void GPUReconstructionCUDA::ReleaseEvent(deviceEvent ev) {}
-void GPUReconstructionCUDA::RecordMarker(deviceEvent ev, int32_t stream) { GPUFailedMsg(cudaEventRecord(ev.get<cudaEvent_t>(), mInternals->Streams[stream])); }
+void GPUReconstructionCUDA::RecordMarker(deviceEvent* ev, int32_t stream) { GPUFailedMsg(cudaEventRecord(ev->get<cudaEvent_t>(), mInternals->Streams[stream])); }
 
 std::unique_ptr<GPUReconstruction::GPUThreadContext> GPUReconstructionCUDA::GetThreadContext()
 {
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -84,7 +84,7 @@ class GPUReconstructionCUDA : public GPUReconstructionKernels<GPUReconstructionC
   size_t WriteToConstantMemory(size_t offset, const void* src, size_t size, int32_t stream = -1, deviceEvent* ev = nullptr) override;
   size_t GPUMemCpy(void* dst, const void* src, size_t size, int32_t stream, int32_t toGPU, deviceEvent* ev = nullptr, deviceEvent* evList = nullptr, int32_t nEvents = 1) override;
   void ReleaseEvent(deviceEvent ev) override;
-  void RecordMarker(deviceEvent ev, int32_t stream) override;
+  void RecordMarker(deviceEvent* ev, int32_t stream) override;
 
   void GetITSTraits(std::unique_ptr<o2::its::TrackerTraits>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame>* timeFrame) override;
 
diff --git a/GPU/GPUTracking/Base/opencl-common/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl-common/GPUReconstructionOCL.cxx
@@ -359,6 +359,11 @@ int32_t GPUReconstructionOCL::InitDevice_Runtime()
     mInternals = master->mInternals;
   }
 
+  for (uint32_t i = 0; i < mEvents.size(); i++) {
+    cl_event* events = (cl_event*)mEvents[i].data();
+    new (events) cl_event[mEvents[i].size()];
+  }
+
   return (0);
 }
 
@@ -432,7 +437,7 @@ size_t GPUReconstructionOCL::WriteToConstantMemory(size_t offset, const void* sr
 
 void GPUReconstructionOCL::ReleaseEvent(deviceEvent ev) { GPUFailedMsg(clReleaseEvent(ev.get<cl_event>())); }
 
-void GPUReconstructionOCL::RecordMarker(deviceEvent ev, int32_t stream) { GPUFailedMsg(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream], 0, nullptr, ev.getEventList<cl_event>())); }
+void GPUReconstructionOCL::RecordMarker(deviceEvent* ev, int32_t stream) { GPUFailedMsg(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream], 0, nullptr, ev->getEventList<cl_event>())); }
 
 int32_t GPUReconstructionOCL::DoStuckProtection(int32_t stream, deviceEvent event)
 {
diff --git a/GPU/GPUTracking/Base/opencl-common/GPUReconstructionOCL.h b/GPU/GPUTracking/Base/opencl-common/GPUReconstructionOCL.h
@@ -52,7 +52,7 @@ class GPUReconstructionOCL : public GPUReconstructionDeviceBase
   size_t WriteToConstantMemory(size_t offset, const void* src, size_t size, int32_t stream = -1, deviceEvent* ev = nullptr) override;
   size_t GPUMemCpy(void* dst, const void* src, size_t size, int32_t stream, int32_t toGPU, deviceEvent* ev = nullptr, deviceEvent* evList = nullptr, int32_t nEvents = 1) override;
   void ReleaseEvent(deviceEvent ev) override;
-  void RecordMarker(deviceEvent ev, int32_t stream) override;
+  void RecordMarker(deviceEvent* ev, int32_t stream) override;
 
   virtual int32_t GetOCLPrograms() = 0;
   virtual bool CheckPlatform(uint32_t i) = 0;
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
@@ -101,7 +101,7 @@ class GPUChain
     }
   }
   inline bool IsEventDone(deviceEvent* evList, int32_t nEvents = 1) { return mRec->IsEventDone(evList, nEvents); }
-  inline void RecordMarker(deviceEvent ev, int32_t stream) { mRec->RecordMarker(ev, stream); }
+  inline void RecordMarker(deviceEvent* ev, int32_t stream) { mRec->RecordMarker(ev, stream); }
   virtual inline std::unique_ptr<GPUReconstruction::GPUThreadContext> GetThreadContext() { return mRec->GetThreadContext(); }
   inline void SynchronizeGPU() { mRec->SynchronizeGPU(); }
   inline void ReleaseEvent(deviceEvent ev, bool doGPU = true)
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -934,7 +934,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         if (transferRunning[lane]) {
           ReleaseEvent(mEvents->stream[lane], doGPU);
         }
-        RecordMarker(mEvents->stream[lane], mRec->NStreams() - 1);
+        RecordMarker(&mEvents->stream[lane], mRec->NStreams() - 1);
         transferRunning[lane] = 1;
       }
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -37,7 +37,7 @@ int32_t GPUChainTracking::RunTPCCompression()
   GPUTPCCompression& CompressorShadow = doGPU ? processorsShadow()->tpcCompressor : Compressor;
   const auto& threadContext = GetThreadContext();
   if (mPipelineFinalizationCtx && GetProcessingSettings().doublePipelineClusterizer) {
-    RecordMarker(mEvents->single, 0);
+    RecordMarker(&mEvents->single, 0);
   }
 
   if (GetProcessingSettings().tpcCompressionGatherMode == 3) {
@@ -124,7 +124,7 @@ int32_t GPUChainTracking::RunTPCCompression()
         return 1;
     }
     if (GetProcessingSettings().tpcCompressionGatherMode == 3) {
-      RecordMarker(mEvents->stream[outputStream], outputStream);
+      RecordMarker(&mEvents->stream[outputStream], outputStream);
       char* deviceFlatPts = (char*)Compressor.mOutput->qTotU;
       if (GetProcessingSettings().doublePipeline) {
         const size_t blockSize = CAMath::nextMultipleOf<1024>(copySize / 30);
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -33,7 +33,7 @@ void GPUChainTracking::RunTPCTrackingMerger_MergeBorderTracks(int8_t withinSlice
   uint32_t n = withinSlice == -1 ? NSLICES / 2 : NSLICES;
   if (GetProcessingSettings().alternateBorderSort && (!mRec->IsGPU() || doGPUall)) {
     TransferMemoryResourceLinkToHost(RecoStep::TPCMerging, Merger.MemoryResMemory(), 0, &mEvents->init);
-    RecordMarker(mEvents->single, 0);
+    RecordMarker(&mEvents->single, 0);
     for (uint32_t i = 0; i < n; i++) {
       int32_t stream = i % mRec->NStreams();
       runKernel<GPUTPCGMMergerMergeBorders, 0>({GetGridAuto(stream, deviceType), krnlRunRangeNone, {nullptr, stream && i < (uint32_t)mRec->NStreams() ? &mEvents->single : nullptr}}, i, withinSlice, mergeMode);
@@ -55,7 +55,7 @@ void GPUChainTracking::RunTPCTrackingMerger_MergeBorderTracks(int8_t withinSlice
       if (i == n - 1) { // Synchronize all execution on stream 0 with the last kernel
         ne = std::min<int32_t>(n, mRec->NStreams());
         for (int32_t j = 1; j < ne; j++) {
-          RecordMarker(mEvents->slice[j], j);
+          RecordMarker(&mEvents->slice[j], j);
         }
         e = &mEvents->slice[1];
         ne--;
@@ -251,7 +251,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   DoDebugAndDump(RecoStep::TPCMerging, 2048, doGPUall, Merger, &GPUTPCGMMerger::DumpFinal, *mDebugFile);
 
   if (doGPUall) {
-    RecordMarker(mEvents->single, 0);
+    RecordMarker(&mEvents->single, 0);
     auto* waitEvent = &mEvents->single;
     if (GetProcessingSettings().keepDisplayMemory || GetProcessingSettings().createO2Output <= 1 || mFractionalQAEnabled) {
       if (!(GetProcessingSettings().keepDisplayMemory || GetProcessingSettings().createO2Output <= 1)) {
@@ -317,7 +317,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
       TransferMemoryResourcesToHost(RecoStep::TPCMerging, &Merger, -1, true);
       runKernel<GPUTPCGMO2Output, GPUTPCGMO2Output::mc>(GetGridAuto(0, GPUReconstruction::krnlDeviceType::CPU));
     } else if (doGPUall) {
-      RecordMarker(mEvents->single, 0);
+      RecordMarker(&mEvents->single, 0);
       TransferMemoryResourceLinkToHost(RecoStep::TPCMerging, Merger.MemoryResOutputO2(), outputStream, nullptr, &mEvents->single);
       TransferMemoryResourceLinkToHost(RecoStep::TPCMerging, Merger.MemoryResOutputO2Clus(), outputStream);
       ReleaseEvent(mEvents->single);
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSliceTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSliceTracker.cxx
@@ -305,7 +305,7 @@ int32_t GPUChainTracking::RunTPCTrackingSlices_internal()
         SynchronizeGPU();
       } else {
         for (int32_t i = 0; i < mRec->NStreams(); i++) {
-          RecordMarker(mEvents->stream[i], i);
+          RecordMarker(&mEvents->stream[i], i);
         }
         runKernel<GPUTPCTrackletConstructor, 1>({GetGridAuto(0), krnlRunRangeNone, {&mEvents->single, mEvents->stream, mRec->NStreams()}});
         for (int32_t i = 0; i < mRec->NStreams(); i++) {

Original file line number	Diff line number	Diff line change
`@@ -548,7 +548,7 @@ size_t GPUReconstructionCUDA::WriteToConstantMemory(size_t offset, const void* s`
`548`	`548`	`}`
`549`	`549`
`550`	`550`	`void GPUReconstructionCUDA::ReleaseEvent(deviceEvent ev) {}`
`551`		`-void GPUReconstructionCUDA::RecordMarker(deviceEvent ev, int32_t stream) { GPUFailedMsg(cudaEventRecord(ev.get<cudaEvent_t>(), mInternals->Streams[stream])); }`
	`551`	`+void GPUReconstructionCUDA::RecordMarker(deviceEvent* ev, int32_t stream) { GPUFailedMsg(cudaEventRecord(ev->get<cudaEvent_t>(), mInternals->Streams[stream])); }`
`552`	`552`
`553`	`553`	`std::unique_ptr<GPUReconstruction::GPUThreadContext> GPUReconstructionCUDA::GetThreadContext()`
`554`	`554`	`{`
Original file line number	Diff line number	Diff line change
`@@ -359,6 +359,11 @@ int32_t GPUReconstructionOCL::InitDevice_Runtime()`
`359`	`359`	`mInternals = master->mInternals;`
`360`	`360`	`}`
`361`	`361`
	`362`	`+ for (uint32_t i = 0; i < mEvents.size(); i++) {`
	`363`	`+ cl_event* events = (cl_event*)mEvents[i].data();`
	`364`	`+ new (events) cl_event[mEvents[i].size()];`
	`365`	`+ }`
	`366`	`+`
`362`	`367`	`return (0);`
`363`	`368`	`}`
`364`	`369`
`@@ -432,7 +437,7 @@ size_t GPUReconstructionOCL::WriteToConstantMemory(size_t offset, const void* sr`
`432`	`437`
`433`	`438`	`void GPUReconstructionOCL::ReleaseEvent(deviceEvent ev) { GPUFailedMsg(clReleaseEvent(ev.get<cl_event>())); }`
`434`	`439`
`435`		`-void GPUReconstructionOCL::RecordMarker(deviceEvent ev, int32_t stream) { GPUFailedMsg(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream], 0, nullptr, ev.getEventList<cl_event>())); }`
	`440`	`+void GPUReconstructionOCL::RecordMarker(deviceEvent* ev, int32_t stream) { GPUFailedMsg(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream], 0, nullptr, ev->getEventList<cl_event>())); }`
`436`	`441`
`437`	`442`	`int32_t GPUReconstructionOCL::DoStuckProtection(int32_t stream, deviceEvent event)`
`438`	`443`	`{`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ class GPUChain`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`	`inline bool IsEventDone(deviceEvent* evList, int32_t nEvents = 1) { return mRec->IsEventDone(evList, nEvents); }`
`104`		`- inline void RecordMarker(deviceEvent ev, int32_t stream) { mRec->RecordMarker(ev, stream); }`
	`104`	`+ inline void RecordMarker(deviceEvent* ev, int32_t stream) { mRec->RecordMarker(ev, stream); }`
`105`	`105`	`virtual inline std::unique_ptr<GPUReconstruction::GPUThreadContext> GetThreadContext() { return mRec->GetThreadContext(); }`
`106`	`106`	`inline void SynchronizeGPU() { mRec->SynchronizeGPU(); }`
`107`	`107`	`inline void ReleaseEvent(deviceEvent ev, bool doGPU = true)`
Original file line number	Diff line number	Diff line change
`@@ -934,7 +934,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)`
`934`	`934`	`if (transferRunning[lane]) {`
`935`	`935`	`ReleaseEvent(mEvents->stream[lane], doGPU);`
`936`	`936`	`}`
`937`		`- RecordMarker(mEvents->stream[lane], mRec->NStreams() - 1);`
	`937`	`+ RecordMarker(&mEvents->stream[lane], mRec->NStreams() - 1);`
`938`	`938`	`transferRunning[lane] = 1;`
`939`	`939`	`}`
`940`	`940`
Original file line number	Diff line number	Diff line change
`@@ -305,7 +305,7 @@ int32_t GPUChainTracking::RunTPCTrackingSlices_internal()`
`305`	`305`	`SynchronizeGPU();`
`306`	`306`	`} else {`
`307`	`307`	`for (int32_t i = 0; i < mRec->NStreams(); i++) {`
`308`		`- RecordMarker(mEvents->stream[i], i);`
	`308`	`+ RecordMarker(&mEvents->stream[i], i);`
`309`	`309`	`}`
`310`	`310`	`runKernel<GPUTPCTrackletConstructor, 1>({GetGridAuto(0), krnlRunRangeNone, {&mEvents->single, mEvents->stream, mRec->NStreams()}});`
`311`	`311`	`for (int32_t i = 0; i < mRec->NStreams(); i++) {`