#include <ProductResolvers.h>

Inheritance diagram for edm::UnscheduledProductResolver:

Public Member Functions
void	setupUnscheduled (UnscheduledConfigurator const &) final

	UnscheduledProductResolver (std::shared_ptr< BranchDescription const > bd)

Public Member Functions inherited from edm::ProducedProductResolver
	ProducedProductResolver (std::shared_ptr< BranchDescription const > bd, ProductStatus iDefaultStatus)

void	resetFailedFromThisProcess () override

Public Member Functions inherited from edm::DataManagingProductResolver
void	connectTo (ProductResolverBase const &, Principal const *) final

	DataManagingProductResolver (std::shared_ptr< BranchDescription const > bd, ProductStatus iDefaultStatus)

void	resetStatus ()

template<bool callResolver, typename FUNC >
ProductResolverBase::Resolution	resolveProductImpl (FUNC resolver) const

Public Member Functions inherited from edm::ProductResolverBase
BranchDescription const &	branchDescription () const

std::string const &	moduleLabel () const

ProductResolverBase &	operator= (ProductResolverBase const &)=delete

void	prefetchAsync (WaitingTask waitTask, Principal const &principal, bool skipCurrentProcess, SharedResourcesAcquirer sra, ModuleCallingContext const *mcc) const

std::string const &	processName () const

ProductID const &	productID () const

std::string const &	productInstanceName () const

ProductProvenance const *	productProvenancePtr () const

bool	productResolved () const

	ProductResolverBase ()

	ProductResolverBase (ProductResolverBase const &)=delete

TypeID	productType () const

bool	productUnavailable () const

bool	productWasDeleted () const

bool	productWasFetchedAndIsValid (bool iSkipCurrentProcess) const

Provenance const *	provenance () const

bool	provenanceAvailable () const

void	putOrMergeProduct (std::unique_ptr< WrapperBase > edp) const

void	putProduct (std::unique_ptr< WrapperBase > edp) const

void	resetBranchDescription (std::shared_ptr< BranchDescription const > bd)

void	resetProductData ()

std::string const &	resolvedModuleLabel () const

Resolution	resolveProduct (Principal const &principal, bool skipCurrentProcess, SharedResourcesAcquirer sra, ModuleCallingContext const mcc) const

void	retrieveAndMerge (Principal const &principal) const

void	setProcessHistory (ProcessHistory const &ph)

void	setProvenance (ProductProvenanceRetriever const *provRetriever, ProcessHistory const &ph, ProductID const &pid)

bool	singleProduct () const

StableProvenance const *	stableProvenance () const

void	unsafe_deleteProduct () const

bool	unscheduledWasNotRun () const

void	write (std::ostream &os) const

virtual	~ProductResolverBase ()

Private Member Functions
void	prefetchAsync_ (WaitingTask waitTask, Principal const &principal, bool skipCurrentProcess, SharedResourcesAcquirer sra, ModuleCallingContext const *mcc) const override

void	resetProductData_ (bool deleteEarly) override

Resolution	resolveProduct_ (Principal const &principal, bool skipCurrentProcess, SharedResourcesAcquirer sra, ModuleCallingContext const mcc) const override

bool	unscheduledWasNotRun_ () const override

Private Attributes
UnscheduledAuxiliary const *	aux_

std::atomic< bool >	prefetchRequested_

WaitingTaskList	waitingTasks_

Worker *	worker_

Additional Inherited Members
Public Types inherited from edm::DataManagingProductResolver
enum	ProductStatus { ProductStatus::ProductSet, ProductStatus::NotPut, ProductStatus::ResolveFailed, ProductStatus::ResolveNotRun, ProductStatus::ProductDeleted }

Protected Member Functions inherited from edm::ProducedProductResolver
void	putProduct_ (std::unique_ptr< WrapperBase > edp) const override

Protected Member Functions inherited from edm::DataManagingProductResolver
ProductStatus	defaultStatus () const

template<bool callResolver, typename FUNC >
Resolution	resolveProductImpl (FUNC resolver) const

void	setFailedStatus () const

void	setProduct (std::unique_ptr< WrapperBase > edp) const

ProductStatus	status () const

Detailed Description

Definition at line 173 of file ProductResolvers.h.

Constructor & Destructor Documentation

edm::UnscheduledProductResolver::UnscheduledProductResolver ( std::shared_ptr< BranchDescription const > bd )

inlineexplicit

Definition at line 175 of file ProductResolvers.h.

References edm::ProductResolverBase::prefetchAsync_(), cmsRelvalreport::principal(), edm::ProductResolverBase::resolveProduct_(), and edm::ProductResolverBase::setupUnscheduled().

                                                                                      :
        ProducedProductResolver(bd,ProductStatus::ResolveNotRun),
        aux_(nullptr),
        prefetchRequested_(false){}

Member Function Documentation

void edm::UnscheduledProductResolver::prefetchAsync_	(	WaitingTask *	waitTask,
		Principal const &	principal,
		bool	skipCurrentProcess,
		SharedResourcesAcquirer *	sra,
		ModuleCallingContext const *	mcc
	)		const

overrideprivatevirtual

Implements edm::ProductResolverBase.

Definition at line 363 of file ProductResolvers.cc.

References event(), edm::ModuleCallingContext::getStreamContext(), edm::make_waiting_task(), cmsRelvalreport::principal(), and lumiQTWidget::t.

   {
     if(skipCurrentProcess) { return; }
     waitingTasks_.add(waitTask);
     bool expected = false;
     if(prefetchRequested_.compare_exchange_strong(expected, true)) {
       
       //Have to create a new task which will make sure the state for UnscheduledProductResolver
       // is properly set after the module has run
       auto t = make_waiting_task(tbb::task::allocate_root(),
                                  [this,&principal, skipCurrentProcess,sra,mcc](std::exception_ptr const* iPtr)
       {
         //The exception is being rethrown because resolveProductImpl sets the ProductResolver to a failed
         // state for the case where an exception occurs during the call to the function.
         try {
           resolveProductImpl<true>([iPtr]() {
             if ( iPtr) {
               std::rethrow_exception(*iPtr);
             }
           });
         } catch(...) {
           waitingTasks_.doneWaiting(std::current_exception());
           return;
         }
         waitingTasks_.doneWaiting(nullptr);
       } );
       auto const& event = static_cast<EventPrincipal const&>(principal);
       ParentContext parentContext(mcc);
 
       worker_->doWorkAsync<OccurrenceTraits<EventPrincipal, BranchActionStreamBegin> >(t,
                                                                                        event,
                                                                                        *(aux_->eventSetup()),
                                                                                        event.streamID(),
                                                                                        parentContext,
                                                                                        mcc->getStreamContext());
     }
   }

void edm::UnscheduledProductResolver::resetProductData_ ( bool deleteEarly )

overrideprivatevirtual

Reimplemented from edm::DataManagingProductResolver.

Definition at line 406 of file ProductResolvers.cc.

References edm::DataManagingProductResolver::resetProductData_().

                                                                 {
     prefetchRequested_ = false;
     waitingTasks_.reset();
     DataManagingProductResolver::resetProductData_(deleteEarly);
   }

ProductResolverBase::Resolution edm::UnscheduledProductResolver::resolveProduct_	(	Principal const &	principal,
		bool	skipCurrentProcess,
		SharedResourcesAcquirer *	sra,
		ModuleCallingContext const *	mcc
	)		const

overrideprivatevirtual

Implements edm::ProductResolverBase.

Definition at line 319 of file ProductResolvers.cc.

References cms::Exception::addContext(), event(), edm::ModuleCallingContext::getStreamContext(), edm::make_sentry(), cmsRelvalreport::principal(), and Resolution.

                                                                                      {
     if (!skipCurrentProcess and worker_) {
       return resolveProductImpl<true>(
         [&principal,this,sra,mcc]() {
           try {
             auto const& event = static_cast<EventPrincipal const&>(principal);
             ParentContext parentContext(mcc);
             aux_->preModuleDelayedGetSignal_.emit(*(mcc->getStreamContext()),*mcc);
 
             auto workCall = [this,&event,&parentContext,mcc] () {
               auto sentry( make_sentry(mcc,[this](ModuleCallingContext const* iContext){aux_->postModuleDelayedGetSignal_.emit(*(iContext->getStreamContext()), *iContext); }));
               
               worker_->doWork<OccurrenceTraits<EventPrincipal, BranchActionStreamBegin> >(
                                            event,
                                            *(aux_->eventSetup()),
                                            event.streamID(),
                                            parentContext,
                                            mcc->getStreamContext());
             };
             
             if (sra) {
               assert(false);
             } else {
               workCall();
             }
 
           }
           catch (cms::Exception & ex) {
             std::ostringstream ost;
             ost << "Calling produce method for unscheduled module "
             << worker_->description().moduleName() << "/'"
             << worker_->description().moduleLabel() << "'";
             ex.addContext(ost.str());
             throw;
           }
         });
     }
     return Resolution(nullptr);
   }

void edm::UnscheduledProductResolver::setupUnscheduled ( UnscheduledConfigurator const & iConfigure )

finalvirtual

Reimplemented from edm::ProductResolverBase.

Definition at line 311 of file ProductResolvers.cc.

References edm::UnscheduledConfigurator::auxiliary(), edm::ProductResolverBase::branchDescription(), edm::UnscheduledConfigurator::findWorker(), and edm::ProductResolverBase::moduleLabel().

                                                                                         {
     aux_ = iConfigure.auxiliary();
     worker_ = iConfigure.findWorker(branchDescription().moduleLabel());
     assert(worker_ != nullptr);
     
   }  