ALPAKA_ACCELERATOR_NAMESPACE::EDMetadata Class Reference

#include <EDMetadata.h>

Public Member Functions
Device	device () const
	EDMetadata (std::shared_ptr< Queue > queue, std::shared_ptr< Event > event)
void	enqueueCallback (edm::WaitingTaskWithArenaHolder holder)
Queue &	queue () const
void	recordEvent ()
void	synchronize (EDMetadata &consumer, bool tryReuseQueue) const
	~EDMetadata ()

Private Member Functions
std::shared_ptr< Queue >	tryReuseQueue_ () const

Private Attributes
std::shared_ptr< Event >	event_
std::atomic< bool >	mayReuseQueue_ = true
std::shared_ptr< Queue >	queue_

Detailed Description

The EDMetadata class provides the exact synchronization mechanisms for Event data products for backends with asynchronous Queue. These include

• adding a notification for edm::WaitingTaskWithArenaHolder
• recording an Event
• synchronizing an Event data product and a consuming EDModule

For synchronous backends the EDMetadata acts as an owner of the Queue object, as no further synchronization is needed.

EDMetadata is used as the Metadata class for edm::DeviceProduct<T>, and is an implementation detail (not visible to user code).

TODO: What to do with device-synchronous backends? The data product needs to be wrapped into the edm::DeviceProduct, but the EDMetadata class used there does not need anything except "dummy" implementation of synchronize(). The question is clearly solvable, so maybe leave it to the time we would actually need one?

Definition at line 61 of file EDMetadata.h.

Constructor & Destructor Documentation

EDMetadata()

ALPAKA_ACCELERATOR_NAMESPACE::EDMetadata::EDMetadata ( std::shared_ptr< Queue >  queue, std::shared_ptr< Event >  event  )

inline

Definition at line 63 of file EDMetadata.h.

        : queue_(std::move(queue)), event_(std::move(event)) {}

~EDMetadata()

ALPAKA_ACCELERATOR_NAMESPACE::EDMetadata::~EDMetadata

(

)

Definition at line 8 of file EDMetadata.cc.

References CMS_SA_ALLOW, event_, and SequenceTypes::wait().

                          {
    // Make sure that the production of the product in the GPU is
    // complete before destructing the product. This is to make sure
    // that the EDM stream does not move to the next event before all
    // asynchronous processing of the current is complete.

    // TODO: a callback notifying a WaitingTaskHolder (or similar)
    // would avoid blocking the CPU, but would also require more work.

    if (event_) {
      // Must not throw in a destructor, and if there were an
      // exception could not really propagate it anyway.
      CMS_SA_ALLOW try { alpaka::wait(*event_); } catch (...) {
      }
    }
  }

Member Function Documentation

device()

Device ALPAKA_ACCELERATOR_NAMESPACE::EDMetadata::device ( ) const

inline

Definition at line 67 of file EDMetadata.h.

References queue_.

{ return alpaka::getDev(*queue_); }

enqueueCallback()

void ALPAKA_ACCELERATOR_NAMESPACE::EDMetadata::enqueueCallback

(

edm::WaitingTaskWithArenaHolder

holder

)

Definition at line 25 of file EDMetadata.cc.

References eostools::move(), and queue_.

                                                                       {
    alpaka::enqueue(*queue_, alpaka::HostOnlyTask([holder = std::move(holder)]() {
      // The functor is required to be const, but the original waitingTaskHolder_
      // needs to be notified...
      const_cast<edm::WaitingTaskWithArenaHolder&>(holder).doneWaiting(nullptr);
    }));
  }

queue()

Queue& ALPAKA_ACCELERATOR_NAMESPACE::EDMetadata::queue ( ) const

inline

Definition at line 71 of file EDMetadata.h.

References queue_.

Referenced by synchronize().

{ return *queue_; }

recordEvent()

void ALPAKA_ACCELERATOR_NAMESPACE::EDMetadata::recordEvent ( )

inline

Definition at line 75 of file EDMetadata.h.

References event_, and queue_.

{ alpaka::enqueue(*queue_, *event_); }

synchronize()

void ALPAKA_ACCELERATOR_NAMESPACE::EDMetadata::synchronize	(	EDMetadata &	consumer,
		bool	tryReuseQueue
	)		const

Synchronizes 'consumer' metadata wrt. 'this' in the event product

Definition at line 33 of file EDMetadata.cc.

References OfflineOutput_cfi::consumer, event_, Exception, edm::errors::LogicError, queue(), queue_, tryReuseQueue_(), and SequenceTypes::wait().

                                                                             {
    if (*queue_ == *consumer.queue_) {
      return;
    }

    if (tryReuseQueue) {
      if (auto queue = tryReuseQueue_()) {
        consumer.queue_ = queue_;
        return;
      }
    }

    // TODO: how necessary this check is?
    if (alpaka::getDev(*queue_) != alpaka::getDev(*consumer.queue_)) {
      throw edm::Exception(edm::errors::LogicError) << "Handling data from multiple devices is not yet supported";
    }

    if (not alpaka::isComplete(*event_)) {
      // Event not yet occurred, so need to add synchronization
      // here. Sychronization is done by making the queue to wait
      // for an event, so all subsequent work in the queue will run
      // only after the event has "occurred" (i.e. data product
      // became available).
      alpaka::wait(*consumer.queue_, *event_);
    }
  }

tryReuseQueue_()

std::shared_ptr< Queue > ALPAKA_ACCELERATOR_NAMESPACE::EDMetadata::tryReuseQueue_ ( ) const

private

Returns a shared_ptr to the Queue if it can be reused, or a null shared_ptr if not

Definition at line 60 of file EDMetadata.cc.

References mayReuseQueue_, and queue_.

Referenced by synchronize().

                                                        {
    bool expected = true;
    if (mayReuseQueue_.compare_exchange_strong(expected, false)) {
      // If the current thread is the one flipping the flag, it may
      // reuse the queue.
      return queue_;
    }
    return nullptr;
  }

Member Data Documentation

event_

std::shared_ptr<Event> ALPAKA_ACCELERATOR_NAMESPACE::EDMetadata::event_

private

Definition at line 90 of file EDMetadata.h.

Referenced by recordEvent(), synchronize(), and ~EDMetadata().

mayReuseQueue_

std::atomic<bool> ALPAKA_ACCELERATOR_NAMESPACE::EDMetadata::mayReuseQueue_ = true

mutableprivate

Definition at line 94 of file EDMetadata.h.

Referenced by tryReuseQueue_().

queue_

std::shared_ptr<Queue> ALPAKA_ACCELERATOR_NAMESPACE::EDMetadata::queue_

private

Definition at line 89 of file EDMetadata.h.

Referenced by device(), enqueueCallback(), queue(), recordEvent(), synchronize(), and tryReuseQueue_().