Inheritance diagram for edm::Worker::RunModuleTask< T >:

Classes
struct	EnableQueueGuard

Public Member Functions
tbb::task *	execute () override

	RunModuleTask (Worker worker, typename T::MyPrincipal const &ep, EventSetupImpl const &es, ServiceToken const &token, StreamID streamID, ParentContext const &parentContext, typename T::Context const context)

Public Member Functions inherited from edm::WaitingTask
std::exception_ptr const *	exceptionPtr () const
	Returns exception thrown by dependent task. More...

	WaitingTask ()
	Constructor. More...

	~WaitingTask () override

Private Attributes
T::Context const *	m_context

EventSetupImpl const &	m_es

ParentContext const	m_parentContext

T::MyPrincipal const &	m_principal

ServiceToken	m_serviceToken

StreamID	m_streamID

Worker *	m_worker

Detailed Description

template<typename T>
class edm::Worker::RunModuleTask< T >

Definition at line 402 of file Worker.h.

Constructor & Destructor Documentation

template<typename T >

edm::Worker::RunModuleTask< T >::RunModuleTask	(	Worker *	worker,
		typename T::MyPrincipal const &	ep,
		EventSetupImpl const &	es,
		ServiceToken const &	token,
		StreamID	streamID,
		ParentContext const &	parentContext,
		typename T::Context const *	context
	)

inline

Definition at line 404 of file Worker.h.

           : m_worker(worker),
             m_principal(ep),
             m_es(es),
             m_streamID(streamID),
             m_parentContext(parentContext),
             m_context(context),
             m_serviceToken(token) {}

Member Function Documentation

template<typename T >

tbb::task* edm::Worker::RunModuleTask< T >::execute ( void )

inlineoverride

Definition at line 433 of file Worker.h.

References f, eostools::move(), cmsRelvalreport::principal(), and createBeamHaloJobs::queue.

                                   {
         //Need to make the services available early so other services can see them
         ServiceRegistry::Operate guard(m_serviceToken);
 
         //incase the emit causes an exception, we need a memory location
         // to hold the exception_ptr
         std::exception_ptr temp_excptr;
         auto excptr = exceptionPtr();
         if (T::isEvent_ && !m_worker->hasAcquire()) {
           try {
             //pre was called in prefetchAsync
             m_worker->emitPostModuleEventPrefetchingSignal();
           } catch (...) {
             temp_excptr = std::current_exception();
             if (not excptr) {
               excptr = &temp_excptr;
             }
           }
         }
 
         if (not excptr) {
           if (auto queue = m_worker->serializeRunModule()) {
             auto const& principal = m_principal;
             auto& es = m_es;
             auto f = [worker = m_worker,
                       &principal,
                       &es,
                       streamID = m_streamID,
                       parentContext = m_parentContext,
                       sContext = m_context,
                       serviceToken = m_serviceToken]() {
               //Need to make the services available
               ServiceRegistry::Operate guard(serviceToken);
 
               //If needed, we pause the queue in begin transition and resume it
               // at the end transition. This guarantees that the module
               // only processes one transition at a time
               EnableQueueGuard enableQueueGuard{workerhelper::CallImpl<T>::enableGlobalQueue(worker)};
               std::exception_ptr* ptr = nullptr;
               worker->template runModuleAfterAsyncPrefetch<T>(ptr, principal, es, streamID, parentContext, sContext);
             };
             //keep another global transition from running if necessary
             auto gQueue = workerhelper::CallImpl<T>::pauseGlobalQueue(m_worker);
             if (gQueue) {
               gQueue->push([queue, gQueue, f]() mutable {
                 gQueue->pause();
                 queue.push(std::move(f));
               });
             } else {
               queue.push(std::move(f));
             }
             return nullptr;
           }
         }
 
         m_worker->runModuleAfterAsyncPrefetch<T>(excptr, m_principal, m_es, m_streamID, m_parentContext, m_context);
         return nullptr;
       }