art::detail::SharedModule Class Reference

#include <SharedModule.h>

Inheritance diagram for art::detail::SharedModule:

Public Member Functions
	SharedModule ()
	SharedModule (std::string const &moduleLabel)
hep::concurrency::SerialTaskQueueChain *	serialTaskQueueChain () const
std::set< std::string > const &	sharedResources () const
void	createQueues (SharedResources const &resources)
template<BranchType , typename... T>
void	serialize (T const &...resources)
template<BranchType , typename... T>
void	serializeExternal (T const &...resources)

Protected Member Functions
template<BranchType BT = InEvent, typename... T>
void	serialize (T const &...)
template<BranchType BT = InEvent, typename... T>
void	serializeExternal (T const &...)
template<BranchType BT = InEvent>
void	async ()

Private Member Functions
void	implicit_serialize ()
void	serialize_for (std::string const &name)
template<typename... T>
void	serialize_for_resource (T const &...t)
template<typename... T>
void	serialize_for_external_resource (T const &...t)

Private Attributes
std::string	moduleLabel_
std::set< std::string >	resourceNames_ {}
bool	asyncDeclared_ {false}
std::unique_ptr< hep::concurrency::SerialTaskQueueChain >	chain_ {nullptr}

Detailed Description

Definition at line 17 of file SharedModule.h.

Constructor & Destructor Documentation

art::detail::SharedModule::SharedModule

(

)

Definition at line 15 of file SharedModule.cc.

: SharedModule{""s} {}

art::detail::SharedModule::SharedModule ( std::string const &  moduleLabel )

explicit

Definition at line 17 of file SharedModule.cc.

    : moduleLabel_{moduleLabel}
  {}

Member Function Documentation

template<BranchType BT = InEvent>

void art::detail::SharedModule::async ( )

inlineprotected

Definition at line 36 of file SharedModule.h.

    {
      static_assert(
        BT == InEvent,
        "async is currently supported only for the 'InEvent' level.");
      asyncDeclared_ = true;
    }

void art::detail::SharedModule::createQueues

(

SharedResources const &

resources

)

Definition at line 34 of file SharedModule.cc.

  {
    Exception e{errors::LogicError,
                "An error occurred while processing scheduling options for a "
                "module.\n"};
    if (asyncDeclared_) {
      if (empty(resourceNames_)) {
        return;
      }
      throw e
        << "async<art::InEvent>() cannot be called in combination with any "
           "serialize<art::InEvent>(...) calls.\n";
    }

    if (empty(resourceNames_)) {
      throw e << "Either 'async<art::InEvent>()' or "
                 "'serialize<art::InEvent>(...)'\n"
                 "must be called in a shared module's constructor.\n";
    }
    std::vector<std::string> const names(cbegin(resourceNames_),
                                         cend(resourceNames_));
    auto queues = resources.createQueues(names);
    chain_ = std::make_unique<SerialTaskQueueChain>(queues);
  }

void art::detail::SharedModule::implicit_serialize ( )

private

Definition at line 60 of file SharedModule.cc.

  {
    // This is the situation where a shared module must be serialized,
    // but only wrt. itself--i.e. only one event call at a time.
    // Because the shared-resources registry is not prepopulated with
    // module names, we call the 'serialize_for_external' function to
    // insert an entry into the registry.  This is safe to do as only
    // this module will refer to the shared resource.
    serialize_for(moduleLabel_);
  }

template<BranchType BT = InEvent, typename... T>

void art::detail::SharedModule::serialize ( T const &  ... )

protected

template<BranchType , typename... T>

void art::detail::SharedModule::serialize

(

T const &...

resources

)

Definition at line 81 of file SharedModule.h.

  {
    serialize_for_resource(resources...);
  }

void art::detail::SharedModule::serialize_for ( std::string const &  name )

private

Definition at line 72 of file SharedModule.cc.

  {
    resourceNames_.emplace(resourceName);
  }

template<typename... T>

void art::detail::SharedModule::serialize_for_external_resource ( T const &...  t )

inlineprivate

Definition at line 63 of file SharedModule.h.

    {
      static_assert(std::conjunction_v<std::is_same<std::string, T>...>);
      if (sizeof...(t) == 0) {
        implicit_serialize();
      } else {
        (serialize_for(t), ...);
      }
    }

template<typename... T>

void art::detail::SharedModule::serialize_for_resource ( T const &...  t )

inlineprivate

Definition at line 50 of file SharedModule.h.

    {
      static_assert(
        std::conjunction_v<std::is_same<detail::SharedResource_t, T>...>);
      if (sizeof...(t) == 0) {
        implicit_serialize();
      } else {
        (serialize_for(t.name), ...);
      }
    }

template<BranchType BT = InEvent, typename... T>

void art::detail::SharedModule::serializeExternal ( T const &  ... )

protected

template<BranchType , typename... T>

void art::detail::SharedModule::serializeExternal

(

T const &...

resources

)

Definition at line 88 of file SharedModule.h.

  {
    serialize_for_external_resource(resources...);
  }

SerialTaskQueueChain * art::detail::SharedModule::serialTaskQueueChain

(

)

const

Definition at line 22 of file SharedModule.cc.

  {
    return chain_.get();
  }

std::set< std::string > const & art::detail::SharedModule::sharedResources

(

)

const

Definition at line 28 of file SharedModule.cc.

  {
    return resourceNames_;
  }

Member Data Documentation

bool art::detail::SharedModule::asyncDeclared_ {false}

private

Definition at line 75 of file SharedModule.h.

std::unique_ptr<hep::concurrency::SerialTaskQueueChain> art::detail::SharedModule::chain_ {nullptr}

private

Definition at line 76 of file SharedModule.h.

std::string art::detail::SharedModule::moduleLabel_

private

Definition at line 73 of file SharedModule.h.

std::set<std::string> art::detail::SharedModule::resourceNames_ {}

private

Definition at line 74 of file SharedModule.h.

---

The documentation for this class was generated from the following files:

• art/art/Framework/Core/detail/SharedModule.h
• art/art/Framework/Core/detail/SharedModule.cc