Fix synchronization mistake in CUDAScopedContext (#327)

Check the event creation only after the product constructor has been called.
Otherwise, if the stream was idle before, and the constructor queues
work to it, the event is not created and downstream will assume that
the product is always there (even if it isn't yet).

Author: makortel

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: