art::detail::SharedModule Class Reference

#include "SharedModule.h"

Inheritance diagram for art::detail::SharedModule:

Public Member Functions
	SharedModule ()
	~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 ( )

default

art::detail::SharedModule::~SharedModule ( )

default

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 38 of file SharedModule.h.

References asyncDeclared_, implicit_serialize(), art::InEvent, and serialize_for().

    {
      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.

References asyncDeclared_, util::cbegin(), util::cend(), chain_, art::detail::SharedResources::createQueues(), e, util::empty(), art::errors::LogicError, and resourceNames_.

Referenced by art::OutputModule::doBeginJob(), art::SharedFilter::setupQueues(), art::SharedProducer::setupQueues(), art::EDFilter::setupQueues(), art::SharedAnalyzer::setupQueues(), art::EDProducer::setupQueues(), and art::EDAnalyzer::setupQueues().

  {
    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.

References moduleLabel_, and serialize_for().

Referenced by async(), serialize_for_external_resource(), and serialize_for_resource().

  {
    // 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

Referenced by simfilter::FilterSimPhotonLiteTime::FilterSimPhotonLiteTime(), simfilter::FilterSimPhotonTime::FilterSimPhotonTime(), art::detail::LegacyModule::LegacyModule(), and art::OutputModule::OutputModule().

template<BranchType , typename... T>

void art::detail::SharedModule::serialize

(

T const &...

resources

)

Definition at line 83 of file SharedModule.h.

References serialize_for_resource().

  {
    serialize_for_resource(resources...);
  }

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

private

Definition at line 72 of file SharedModule.cc.

References resourceNames_.

Referenced by async(), implicit_serialize(), serialize_for_external_resource(), and serialize_for_resource().

  {
    resourceNames_.emplace(resourceName);
  }

template<typename... T>

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

inlineprivate

Definition at line 65 of file SharedModule.h.

References implicit_serialize(), and serialize_for().

Referenced by serializeExternal().

    {
      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 52 of file SharedModule.h.

References implicit_serialize(), and serialize_for().

Referenced by serialize().

    {
      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

Referenced by wcls::WireCellToolkit::WireCellToolkit().

template<BranchType , typename... T>

void art::detail::SharedModule::serializeExternal

(

T const &...

resources

)

Definition at line 90 of file SharedModule.h.

References serialize_for_external_resource().

  {
    serialize_for_external_resource(resources...);
  }

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

(

)

const

Definition at line 22 of file SharedModule.cc.

References chain_.

  {
    return chain_.get();
  }

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

(

)

const

Definition at line 28 of file SharedModule.cc.

References resourceNames_.

  {
    return resourceNames_;
  }

Member Data Documentation

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

private

Definition at line 77 of file SharedModule.h.

Referenced by async(), and createQueues().

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

private

Definition at line 78 of file SharedModule.h.

Referenced by createQueues(), and serialTaskQueueChain().

std::string art::detail::SharedModule::moduleLabel_ {}

private

Definition at line 75 of file SharedModule.h.

Referenced by implicit_serialize().

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

private

Definition at line 76 of file SharedModule.h.

Referenced by createQueues(), serialize_for(), and sharedResources().

---

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

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