EDMetadata.h

Go to the documentation of this file.

#ifndef HeterogeneousCore_AlpakaCore_interface_alpaka_EDMetadata_h
#define HeterogeneousCore_AlpakaCore_interface_alpaka_EDMetadata_h

#include <atomic>
#include <memory>

#include <alpaka/alpaka.hpp>

#include "FWCore/Concurrency/interface/WaitingTaskWithArenaHolder.h"
#include "HeterogeneousCore/AlpakaInterface/interface/config.h"
#include "HeterogeneousCore/AlpakaInterface/interface/HostOnlyTask.h"

namespace ALPAKA_ACCELERATOR_NAMESPACE {
#ifdef ALPAKA_ACC_CPU_B_SEQ_T_SEQ_ENABLED
  // Host backends with a synchronous queue

  class EDMetadata {
  public:
    EDMetadata(std::shared_ptr<Queue> queue) : queue_(std::move(queue)) {}

    Device device() const { return alpaka::getDev(*queue_); }

    // Alpaka operations do not accept a temporary as an argument
    // TODO: Returning non-const reference here is BAD
    Queue& queue() const { return *queue_; }

    void recordEvent() {}
    void discardEvent() {}

  private:
    std::shared_ptr<Queue> queue_;
  };

  // TODO: else if device backends with a synchronous queue

#else
  // All backends with an asynchronous queue

  class EDMetadata {
  public:
    EDMetadata(std::shared_ptr<Queue> queue, std::shared_ptr<Event> event)
        : queue_(std::move(queue)), event_(std::move(event)) {}
    ~EDMetadata();

    Device device() const { return alpaka::getDev(*queue_); }

    // Alpaka operations do not accept a temporary as an argument
    // TODO: Returning non-const reference here is BAD
    Queue& queue() const { return *queue_; }

    void enqueueCallback(edm::WaitingTaskWithArenaHolder holder);

    void recordEvent() { alpaka::enqueue(*queue_, *event_); }
    void discardEvent() { event_.reset(); }

    void synchronize(EDMetadata& consumer, bool tryReuseQueue) const;

  private:
    std::shared_ptr<Queue> tryReuseQueue_() const;

    std::shared_ptr<Queue> queue_;
    std::shared_ptr<Event> event_;
    // This flag tells whether the Queue may be reused by a
    // consumer or not. The goal is to have a "chain" of modules to
    // queue their work to the same queue.
    mutable std::atomic<bool> mayReuseQueue_ = true;
    // Cache to potentially reduce alpaka::wait() calls
    mutable std::atomic<bool> eventComplete_ = false;
  };
#endif
}  // namespace ALPAKA_ACCELERATOR_NAMESPACE

#endif