ALPAKA_ACCELERATOR_NAMESPACE::ProducerBase< BaseT, Args > Class Template Reference

#include <ProducerBase.h>

Inheritance diagram for ALPAKA_ACCELERATOR_NAMESPACE::ProducerBase< BaseT, Args >:

Public Member Functions
template<edm::Transition Tr = edm::Transition::Event>
auto	produces () noexcept
template<edm::Transition Tr = edm::Transition::Event>
auto	produces (std::string instanceName) noexcept

Private Types
using	Base = BaseT< Args..., edm::Transformer >

Private Member Functions
template<typename TProduct , typename TToken , edm::Transition Tr>
edm::EDPutTokenT< TToken >	deviceProduces (std::string instanceName)
template<typename TProduct , edm::Transition Tr>
edm::EDPutTokenT< TProduct >	produces (std::string instanceName)

Friends
template<typename TProducer , edm::Transition Tr>
class	ProducerBaseAdaptor

Detailed Description

template<template< typename... > class BaseT, typename... Args>
class ALPAKA_ACCELERATOR_NAMESPACE::ProducerBase< BaseT, Args >

The ProducerBase acts as a common base class for all Alpaka EDProducers. The main benefit is to have a single place for the definition of produces() functions.

The produces() functions return a custom ProducerBaseAdaptor in order to call the deviceProduces(). For device or asynchronous backends the deviceProduces() registers the automatic transfer to host and a transformation from edm::DeviceProduct<T> to U, where U is the host-equivalent of T. The transformation from T to U is done by a specialization of cms::alpakatools::TransferToHost<T> template, that should be provided in the same file where T is defined.

TODO: add "override" for labelsForToken()

Definition at line 37 of file ProducerBase.h.

Member Typedef Documentation

Base

template<template< typename... > class BaseT, typename... Args>

using ALPAKA_ACCELERATOR_NAMESPACE::ProducerBase< BaseT, Args >::Base = BaseT<Args..., edm::Transformer>

private

Definition at line 41 of file ProducerBase.h.

Member Function Documentation

deviceProduces()

template<template< typename... > class BaseT, typename... Args>

template<typename TProduct , typename TToken , edm::Transition Tr>

edm::EDPutTokenT<TToken> ALPAKA_ACCELERATOR_NAMESPACE::ProducerBase< BaseT, Args >::deviceProduces ( std::string  instanceName )

inlineprivate

Definition at line 72 of file ProducerBase.h.

                                                                  {
      edm::EDPutTokenT<TToken> token = Base::template produces<TToken, Tr>(std::move(instanceName));
      // TODO: should host-synchronous backend(s) have DeviceProduct<TProduct> branch?
#ifndef ALPAKA_ACC_CPU_B_SEQ_T_SEQ_ENABLED
      // All device backends or devices with asynchronous queue

      // TODO: in principle we could also decide to not register the
      // transfer to host if the TransferToHost<T> has not been
      // specialized for TProduct.
      this->registerTransformAsync(
          token,
          [](TToken const& deviceProduct, edm::WaitingTaskWithArenaHolder holder) {
            auto const& device = alpaka::getDev(deviceProduct.template metadata<EDMetadata>().queue());
            detail::EDMetadataAcquireSentry sentry(device, std::move(holder));
            auto metadataPtr = sentry.metadata();
            constexpr bool tryReuseQueue = true;
            TProduct const& productOnDevice =
                deviceProduct.template getSynchronized<EDMetadata>(*metadataPtr, tryReuseQueue);

            using TransferT = cms::alpakatools::TransferToHost<TProduct>;
            using HostType = typename TransferT::HostDataType;
            HostType productOnHost = TransferT::transferAsync(metadataPtr->queue(), productOnDevice);

            // Need to keep the EDMetadata object from sentry.finish()
            // alive until the synchronization
            using TplType = std::tuple<HostType, std::shared_ptr<EDMetadata>>;
            // Wrap possibly move-only type into a copyable type
            return std::make_shared<TplType>(std::move(productOnHost), sentry.finish());
          },
          [](auto tplPtr) { return std::move(std::get<0>(*tplPtr)); });
#endif
      return token;
    }

produces() [1/3]

template<template< typename... > class BaseT, typename... Args>

template<edm::Transition Tr = edm::Transition::Event>

auto ALPAKA_ACCELERATOR_NAMESPACE::ProducerBase< BaseT, Args >::produces ( )

inlinenoexcept

Definition at line 45 of file ProducerBase.h.

                                           {
      return ProducerBaseAdaptor<ProducerBase, Tr>(*this);
    }

produces() [2/3]

template<template< typename... > class BaseT, typename... Args>

template<edm::Transition Tr = edm::Transition::Event>

auto ALPAKA_ACCELERATOR_NAMESPACE::ProducerBase< BaseT, Args >::produces ( std::string  instanceName )

inlinenoexcept

Definition at line 50 of file ProducerBase.h.

                                                                 {
      return ProducerBaseAdaptor<ProducerBase, Tr>(*this, std::move(instanceName));
    }

produces() [3/3]

template<template< typename... > class BaseT, typename... Args>

template<typename TProduct , edm::Transition Tr>

edm::EDPutTokenT<TProduct> ALPAKA_ACCELERATOR_NAMESPACE::ProducerBase< BaseT, Args >::produces ( std::string  instanceName )

inlineprivate

Definition at line 63 of file ProducerBase.h.

                                                              {
      return Base::template produces<TProduct, Tr>(std::move(instanceName));
    }

Friends And Related Function Documentation

ProducerBaseAdaptor

template<template< typename... > class BaseT, typename... Args>

template<typename TProducer , edm::Transition Tr>

friend class ProducerBaseAdaptor

friend

Definition at line 56 of file ProducerBase.h.