Fix synchronization mistake in CUDAScopedContext

CUDADataFormats/Common/interface/CUDAProduct.h

@@ -40,14 +40,14 @@ class CUDAProduct: public CUDAProductBase {
   friend class CUDAScopedContext;
   friend class edm::Wrapper<CUDAProduct<T>>;
 
-  explicit CUDAProduct(int device, std::shared_ptr<cuda::stream_t<>> stream, std::shared_ptr<cuda::event_t> event, T data):
-    CUDAProductBase(device, std::move(stream), std::move(event)),
+  explicit CUDAProduct(int device, std::shared_ptr<cuda::stream_t<>> stream, T data):
+    CUDAProductBase(device, std::move(stream)),
     data_(std::move(data))
   {}
 
   template <typename... Args>
-  explicit CUDAProduct(int device, std::shared_ptr<cuda::stream_t<>> stream, std::shared_ptr<cuda::event_t> event, Args&&... args):
-    CUDAProductBase(device, std::move(stream), std::move(event)),
+  explicit CUDAProduct(int device, std::shared_ptr<cuda::stream_t<>> stream, Args&&... args):
+    CUDAProductBase(device, std::move(stream)),
     data_(std::forward<Args>(args)...)
   {}
 

CUDADataFormats/Common/interface/CUDAProductBase.h

@@ -40,12 +40,18 @@ class CUDAProductBase {
   cuda::event_t *event() { return event_.get(); }
 
 protected:
-  explicit CUDAProductBase(int device, std::shared_ptr<cuda::stream_t<>> stream, std::shared_ptr<cuda::event_t> event);
+  explicit CUDAProductBase(int device, std::shared_ptr<cuda::stream_t<>> stream):
+    stream_{std::move(stream)},
+    device_{device}
+  {}
 
 private:
   friend class CUDAScopedContext;
 
-  // Intended to be used only from CUDAScopedContext
+  // The following functions are intended to be used only from CUDAScopedContext
+  void setEvent(std::shared_ptr<cuda::event_t> event) {
+    event_ = std::move(event);
+  }
   const std::shared_ptr<cuda::stream_t<>>& streamPtr() const { return stream_; }
 
   bool mayReuseStream() const {

CUDADataFormats/Common/src/CUDAProductBase.cc

@@ -3,12 +3,6 @@
 #include "FWCore/ServiceRegistry/interface/Service.h"
 #include "HeterogeneousCore/CUDAServices/interface/CUDAService.h"
 
-CUDAProductBase::CUDAProductBase(int device, std::shared_ptr<cuda::stream_t<>> stream, std::shared_ptr<cuda::event_t> event):
-  stream_(std::move(stream)),
-  event_(std::move(event)),
-  device_(device)
-{}
-
 bool CUDAProductBase::isAvailable() const {
   // In absence of event, the product was available already at the end
   // of produce() of the producer.

HeterogeneousCore/CUDACore/interface/CUDAScopedContext.h

@@ -73,19 +73,23 @@ class CUDAScopedContext {
 
   template <typename T>
   std::unique_ptr<CUDAProduct<T> > wrap(T data) {
-    createEventIfStreamBusy();
     // make_unique doesn't work because of private constructor
     //
     // CUDAProduct<T> constructor records CUDA event to the CUDA
     // stream. The event will become "occurred" after all work queued
     // to the stream before this point has been finished.
-    return std::unique_ptr<CUDAProduct<T> >(new CUDAProduct<T>(device(), streamPtr(), event_, std::move(data)));
+    std::unique_ptr<CUDAProduct<T> > ret(new CUDAProduct<T>(device(), streamPtr(), std::move(data)));
+    createEventIfStreamBusy();
+    ret->setEvent(event_);
+    return ret;
   }
 
   template <typename T, typename... Args>
   auto emplace(edm::Event& iEvent, edm::EDPutTokenT<T> token, Args&&... args) {
+    auto ret = iEvent.emplace(token, device(), streamPtr(), std::forward<Args>(args)...);
     createEventIfStreamBusy();
-    return iEvent.emplace(token, device(), streamPtr(), event_, std::forward<Args>(args)...);
+    const_cast<T&>(*ret).setEvent(event_);
+    return ret;
   }
 
 private: