#include <EventSetupProvider.h>

Public Types
typedef std::pair< DataType, DataLabel >	DataKeyInfo

typedef std::string	DataLabel

typedef std::string	DataType

typedef std::map < ComponentDescription, RecordToDataMap >	PreferredProviderInfo

typedef std::string	RecordName

typedef std::multimap < RecordName, DataKeyInfo >	RecordToDataMap

Public Member Functions
void	add (std::shared_ptr< DataProxyProvider >)

void	add (std::shared_ptr< EventSetupRecordIntervalFinder >)

void	addRecord (const EventSetupRecordKey &iKey)
	Intended for use only in tests. More...

void	checkESProducerSharing (EventSetupProvider &precedingESProvider, std::set< ParameterSetIDHolder > &sharingCheckDone, std::map< EventSetupRecordKey, std::vector< ComponentDescription const * >> &referencedESProducers, EventSetupsController &esController)

void	clearInitializationData ()

bool	doRecordsMatch (EventSetupProvider &precedingESProvider, EventSetupRecordKey const &eventSetupRecordKey, std::map< EventSetupRecordKey, bool > &allComponentsMatch, EventSetupsController const &esController)

bool	doWeNeedToWaitForIOVsToFinish (IOVSyncValue const &) const

std::shared_ptr< const EventSetupImpl >	eventSetupForInstance (IOVSyncValue const &, bool &newEventSetupImpl)

EventSetupImpl const &	eventSetupImpl () const

	EventSetupProvider (ActivityRegistry const , unsigned subProcessIndex=0U, PreferredProviderInfo const iInfo=nullptr)

	EventSetupProvider (EventSetupProvider const &)=delete

void	fillKeys (std::set< EventSetupRecordKey > &keys) const

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

void	fillReferencedDataKeys (EventSetupRecordKey const &eventSetupRecordKey)

void	finishConfiguration (NumberOfConcurrentIOVs const &, bool &hasNonconcurrentFinder)

void	forceCacheClear ()
	Used when testing that all code properly updates on IOV changes of all Records. More...

EventSetupProvider const &	operator= (EventSetupProvider const &)=delete

std::set< ComponentDescription >	proxyProviderDescriptions () const

ESRecordsToProxyIndices	recordsToProxyIndices () const

void	replaceExisting (std::shared_ptr< DataProxyProvider >)

void	resetRecordPlusDependentRecords (EventSetupRecordKey const &)
	Used when we need to force a Record to reset all its proxies. More...

void	resetRecordToProxyPointers ()

void	setAllValidityIntervals (const IOVSyncValue &iValue)
	Set the validity intervals in all EventSetupRecordProviders. More...

void	setPreferredProviderInfo (PreferredProviderInfo const &iInfo)

unsigned	subProcessIndex () const

EventSetupRecordProvider *	tryToGetRecordProvider (const EventSetupRecordKey &iKey)

	~EventSetupProvider ()

Static Public Member Functions
static void	logInfoWhenSharing (ParameterSet const &iConfiguration)

Private Types
using	RecordKeys = std::vector< EventSetupRecordKey >

using	RecordProviders = std::vector< std::shared_ptr< EventSetupRecordProvider >>

Private Member Functions
void	determinePreferred ()

void	insert (EventSetupRecordKey const &, std::unique_ptr< EventSetupRecordProvider >)

std::shared_ptr < EventSetupRecordProvider > &	recordProvider (const EventSetupRecordKey &iKey)

Private Attributes
ActivityRegistry const *	activityRegistry_

std::unique_ptr< std::vector < std::shared_ptr < DataProxyProvider > > >	dataProviders_

propagate_const < std::shared_ptr < EventSetupImpl > >	eventSetupImpl_

std::unique_ptr< std::vector < std::shared_ptr < EventSetupRecordIntervalFinder > > >	finders_

bool	mustFinishConfiguration_

std::unique_ptr < PreferredProviderInfo >	preferredProviderInfo_

std::unique_ptr< std::map < ParameterSetIDHolder, std::set< EventSetupRecordKey > > >	psetIDToRecordKey_

RecordKeys	recordKeys_

RecordProviders	recordProviders_

std::unique_ptr< std::set < EventSetupRecordKey > >	recordsWithALooperProxy_

std::unique_ptr< std::map < EventSetupRecordKey, std::vector< std::shared_ptr < EventSetupRecordIntervalFinder > > > >	recordToFinders_

std::unique_ptr< std::map < EventSetupRecordKey, std::map< DataKey, ComponentDescription > > >	recordToPreferred_

std::unique_ptr< std::map < EventSetupRecordKey, std::map< DataKey, ComponentDescription const * > > >	referencedDataKeys_

unsigned	subProcessIndex_

Detailed Description

Description: Factory for a EventSetup

Usage: <usage>

Definition at line 49 of file EventSetupProvider.h.

Member Typedef Documentation

typedef std::pair<DataType, DataLabel> edm::eventsetup::EventSetupProvider::DataKeyInfo

Definition at line 54 of file EventSetupProvider.h.

typedef std::string edm::eventsetup::EventSetupProvider::DataLabel

Definition at line 53 of file EventSetupProvider.h.

typedef std::string edm::eventsetup::EventSetupProvider::DataType

Definition at line 52 of file EventSetupProvider.h.

typedef std::map<ComponentDescription, RecordToDataMap> edm::eventsetup::EventSetupProvider::PreferredProviderInfo

Definition at line 56 of file EventSetupProvider.h.

using edm::eventsetup::EventSetupProvider::RecordKeys = std::vector<EventSetupRecordKey>

private

Definition at line 130 of file EventSetupProvider.h.

typedef std::string edm::eventsetup::EventSetupProvider::RecordName

Definition at line 51 of file EventSetupProvider.h.

using edm::eventsetup::EventSetupProvider::RecordProviders = std::vector<std::shared_ptr<EventSetupRecordProvider>>

private

Definition at line 133 of file EventSetupProvider.h.

typedef std::multimap<RecordName, DataKeyInfo> edm::eventsetup::EventSetupProvider::RecordToDataMap

Definition at line 55 of file EventSetupProvider.h.

Constructor & Destructor Documentation

edm::eventsetup::EventSetupProvider::EventSetupProvider	(	ActivityRegistry const *	activityRegistry,
		unsigned	subProcessIndex = `0U`,
		PreferredProviderInfo const *	iInfo = `nullptr`
	)

Definition at line 41 of file EventSetupProvider.cc.

         : activityRegistry_(activityRegistry),
           mustFinishConfiguration_(true),
           subProcessIndex_(subProcessIndex),
           preferredProviderInfo_((nullptr != iInfo) ? (new PreferredProviderInfo(*iInfo)) : nullptr),
           finders_(new std::vector<std::shared_ptr<EventSetupRecordIntervalFinder>>()),
           dataProviders_(new std::vector<std::shared_ptr<DataProxyProvider>>()),
           referencedDataKeys_(new std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription const*>>),
           recordToFinders_(
               new std::map<EventSetupRecordKey, std::vector<std::shared_ptr<EventSetupRecordIntervalFinder>>>),
           psetIDToRecordKey_(new std::map<ParameterSetIDHolder, std::set<EventSetupRecordKey>>),
           recordToPreferred_(new std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription>>),
           recordsWithALooperProxy_(new std::set<EventSetupRecordKey>) {}

edm::eventsetup::EventSetupProvider::EventSetupProvider ( EventSetupProvider const & )

delete

edm::eventsetup::EventSetupProvider::~EventSetupProvider ( )

Definition at line 57 of file EventSetupProvider.cc.

References forceCacheClear().

57 { forceCacheClear(); }

edm::eventsetup::EventSetupProvider::forceCacheClear

void forceCacheClear()

Used when testing that all code properly updates on IOV changes of all Records.

Definition: EventSetupProvider.cc:388

Member Function Documentation

void edm::eventsetup::EventSetupProvider::add ( std::shared_ptr< DataProxyProvider > iProvider )

Definition at line 90 of file EventSetupProvider.cc.

References activityRegistry_, cms::cuda::assert(), dataProviders_, and edm::ActivityRegistry::postESModuleRegistrationSignal_.

Referenced by edm::eventsetup::looper::addFinderTo(), edm::eventsetup::addProviderTo(), edm::eventsetup::looper::addProviderTo(), edm::eventsetup::ModuleMakerTraits::addTo(), edm::eventsetup::SourceMakerTraits::addTo(), counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                                            {
       assert(iProvider.get() != nullptr);
       dataProviders_->push_back(iProvider);
       if (activityRegistry_) {
         activityRegistry_->postESModuleRegistrationSignal_(iProvider->description());
       }
     }

void edm::eventsetup::EventSetupProvider::add ( std::shared_ptr< EventSetupRecordIntervalFinder > iFinder )

Definition at line 106 of file EventSetupProvider.cc.

References cms::cuda::assert(), and finders_.

Referenced by counter.Counter::register(), SequenceTypes.Task::remove(), and SequenceTypes.Task::replace().

                                                                                       {
       assert(iFinder.get() != nullptr);
       finders_->push_back(iFinder);
     }

void edm::eventsetup::EventSetupProvider::addRecord ( const EventSetupRecordKey & iKey )

Intended for use only in tests.

Definition at line 740 of file EventSetupProvider.cc.

References eventSetupImpl_, insert(), and recordKeys_.

                                                                       {
       insert(iKey, std::unique_ptr<EventSetupRecordProvider>());
       eventSetupImpl_->setKeyIters(recordKeys_.begin(), recordKeys_.end());
     }

void edm::eventsetup::EventSetupProvider::checkESProducerSharing	(	EventSetupProvider &	precedingESProvider,
		std::set< ParameterSetIDHolder > &	sharingCheckDone,
		std::map< EventSetupRecordKey, std::vector< ComponentDescription const * >> &	referencedESProducers,
		EventSetupsController &	esController
	)

Definition at line 396 of file EventSetupProvider.cc.

References cms::cuda::assert(), doRecordsMatch(), edm::eventsetup::ComponentFactory< T >::get(), edm::eventsetup::EventSetupsController::getESProducerPSet(), edm::eventsetup::EventSetupsController::isFirstMatch(), edm::eventsetup::EventSetupsController::isLastMatch(), submitPVResolutionJobs::key, logInfoWhenSharing(), edm::eventsetup::EventSetupsController::lookForMatches(), edm::match(), TrackValidation_cff::pset, psetIDToRecordKey_, recordProvider(), recordProviders_, subProcessIndex(), and subProcessIndex_.

                                              {
       edm::LogVerbatim("EventSetupSharing")
           << "EventSetupProvider::checkESProducerSharing: Checking processes with SubProcess Indexes "
           << subProcessIndex() << " and " << precedingESProvider.subProcessIndex();
 
       if (referencedESProducers.empty()) {
         for (auto& recProvider : recordProviders_) {
           recProvider->getReferencedESProducers(referencedESProducers);
         }
       }
 
       // This records whether the configurations of all the DataProxyProviders
       // and finders matches for a particular pair of processes and
       // a particular record and also the records it depends on.
       std::map<EventSetupRecordKey, bool> allComponentsMatch;
 
       std::map<ParameterSetID, bool> candidateNotRejectedYet;
 
       // Loop over all the ESProducers which have a DataProxy
       // referenced by any EventSetupRecord in this EventSetupProvider
       for (auto const& iRecord : referencedESProducers) {
         for (auto const& iComponent : iRecord.second) {
           ParameterSetID const& psetID = iComponent->pid_;
           ParameterSetIDHolder psetIDHolder(psetID);
           if (sharingCheckDone.find(psetIDHolder) != sharingCheckDone.end())
             continue;
 
           bool firstProcessWithThisPSet = false;
           bool precedingHasMatchingPSet = false;
 
           esController.lookForMatches(psetID,
                                       subProcessIndex_,
                                       precedingESProvider.subProcessIndex_,
                                       firstProcessWithThisPSet,
                                       precedingHasMatchingPSet);
 
           if (firstProcessWithThisPSet) {
             sharingCheckDone.insert(psetIDHolder);
             allComponentsMatch[iRecord.first] = false;
             continue;
           }
 
           if (!precedingHasMatchingPSet) {
             allComponentsMatch[iRecord.first] = false;
             continue;
           }
 
           // An ESProducer that survives to this point is a candidate.
           // It was shared with some other process in the first pass where
           // ESProducers were constructed and one of three possibilities exists:
           //    1) It should not have been shared and a new ESProducer needs
           //    to be created and the proper pointers set.
           //    2) It should have been shared with a different preceding process
           //    in which case some pointers need to be modified.
           //    3) It was originally shared which the correct prior process
           //    in which case nothing needs to be done, but we do need to
           //    do some work to verify that.
           // Make an entry in a map for each of these ESProducers. We
           // will set the value to false if and when we determine
           // the ESProducer cannot be shared between this pair of processes.
           auto iCandidateNotRejectedYet = candidateNotRejectedYet.find(psetID);
           if (iCandidateNotRejectedYet == candidateNotRejectedYet.end()) {
             candidateNotRejectedYet[psetID] = true;
             iCandidateNotRejectedYet = candidateNotRejectedYet.find(psetID);
           }
 
           // At this point we know that the two processes both
           // have an ESProducer matching the type and label in
           // iComponent and also with exactly the same configuration.
           // And there was not an earlier preceding process
           // where the same instance of the ESProducer could
           // have been shared.  And this ESProducer was referenced
           // by the later process's EventSetupRecord (preferred or
           // or just the only thing that could have made the data).
           // To determine if sharing is allowed, now we need to
           // check if all the DataProxyProviders and all the
           // finders are the same for this record and also for
           // all records this record depends on. And even
           // if this is true, we have to wait until the loop
           // ends because some other DataProxy associated with
           // the ESProducer could write to a different record where
           // the same determination will need to be repeated. Only if
           // all of the the DataProxy's can be shared, can the ESProducer
           // instance be shared across processes.
 
           if (iCandidateNotRejectedYet->second == true) {
             auto iAllComponentsMatch = allComponentsMatch.find(iRecord.first);
             if (iAllComponentsMatch == allComponentsMatch.end()) {
               // We do not know the value in AllComponents yet and
               // we need it now so we have to do the difficult calculation
               // now.
               bool match = doRecordsMatch(precedingESProvider, iRecord.first, allComponentsMatch, esController);
               allComponentsMatch[iRecord.first] = match;
               iAllComponentsMatch = allComponentsMatch.find(iRecord.first);
             }
             if (!iAllComponentsMatch->second) {
               iCandidateNotRejectedYet->second = false;
             }
           }
         }  // end loop over components used by record
       }    // end loop over records
 
       // Loop over candidates
       for (auto const& candidate : candidateNotRejectedYet) {
         ParameterSetID const& psetID = candidate.first;
         bool canBeShared = candidate.second;
         if (canBeShared) {
           ParameterSet const& pset = *esController.getESProducerPSet(psetID, subProcessIndex_);
           logInfoWhenSharing(pset);
           ParameterSetIDHolder psetIDHolder(psetID);
           sharingCheckDone.insert(psetIDHolder);
           if (esController.isFirstMatch(psetID, subProcessIndex_, precedingESProvider.subProcessIndex_)) {
             continue;  // Proper sharing was already done. Nothing more to do.
           }
 
           // Need to reset the pointer from the EventSetupRecordProvider to the
           // the DataProxyProvider so these two processes share an ESProducer.
 
           std::shared_ptr<DataProxyProvider> dataProxyProvider;
           std::set<EventSetupRecordKey> const& keysForPSetID1 = (*precedingESProvider.psetIDToRecordKey_)[psetIDHolder];
           for (auto const& key : keysForPSetID1) {
             dataProxyProvider = precedingESProvider.recordProvider(key)->proxyProvider(psetIDHolder);
             assert(dataProxyProvider);
             break;
           }
 
           std::set<EventSetupRecordKey> const& keysForPSetID2 = (*psetIDToRecordKey_)[psetIDHolder];
           for (auto const& key : keysForPSetID2) {
             recordProvider(key)->resetProxyProvider(psetIDHolder, dataProxyProvider);
           }
         } else {
           if (esController.isLastMatch(psetID, subProcessIndex_, precedingESProvider.subProcessIndex_)) {
             ParameterSet const& pset = *esController.getESProducerPSet(psetID, subProcessIndex_);
             ModuleFactory::get()->addTo(esController, *this, pset, true);
           }
         }
       }
     }

void edm::eventsetup::EventSetupProvider::clearInitializationData ( )

Definition at line 646 of file EventSetupProvider.cc.

References preferredProviderInfo_, psetIDToRecordKey_, recordsWithALooperProxy_, recordToFinders_, recordToPreferred_, and referencedDataKeys_.

                                                      {
       preferredProviderInfo_.reset();
       referencedDataKeys_.reset();
       recordToFinders_.reset();
       psetIDToRecordKey_.reset();
       recordToPreferred_.reset();
       recordsWithALooperProxy_.reset();
     }

void edm::eventsetup::EventSetupProvider::determinePreferred ( )

private

Definition at line 161 of file EventSetupProvider.cc.

References makeMuonMisalignmentScenario::components, edm::eventsetup::DataProxyProvider::KeyedProxies::contains(), Exception, edm::eventsetup::heterocontainer::HCTypeTag::findType(), edm::eventsetup::preferEverything(), preferredProviderInfo_, edm::eventsetup::EventSetupRecordProvider::proxyProvider(), edm::eventsetup::EventSetupRecordProvider::proxyProviderDescriptions(), align_cfg::recordName, recordProvider(), recordProviders_, recordToPreferred_, AlCaHLTBitMon_QueryRunRegistry::string, and edm::eventsetup::EventSetupRecordKey::type().

Referenced by finishConfiguration().

                                                 {
       using namespace edm::eventsetup;
       if (preferredProviderInfo_) {
         for (auto const& itInfo : *preferredProviderInfo_) {
           if (itInfo.second.empty()) {
             //want everything
             preferEverything(itInfo.first, recordProviders_, *recordToPreferred_);
           } else {
             for (auto const& itRecData : itInfo.second) {
               std::string recordName = itRecData.first;
               EventSetupRecordKey recordKey(eventsetup::EventSetupRecordKey::TypeTag::findType(recordName));
               if (recordKey.type() == eventsetup::EventSetupRecordKey::TypeTag()) {
                 throw cms::Exception("ESPreferUnknownRecord")
                     << "Unknown record \"" << recordName
                     << "\" used in es_prefer statement for type=" << itInfo.first.type_ << " label=\""
                     << itInfo.first.label_ << "\"\n Please check spelling.";
                 //record not found
               }
               //See if the ProxyProvider provides something for this Record
               EventSetupRecordProvider& recordProviderForKey = *recordProvider(recordKey);
 
               std::set<ComponentDescription> components = recordProviderForKey.proxyProviderDescriptions();
               std::set<ComponentDescription>::iterator itProxyProv = components.find(itInfo.first);
               if (itProxyProv == components.end()) {
                 throw cms::Exception("ESPreferWrongRecord")
                     << "The type=" << itInfo.first.type_ << " label=\"" << itInfo.first.label_
                     << "\" does not provide data for the Record " << recordName;
               }
               //Does it data type exist?
               eventsetup::TypeTag datumType = eventsetup::TypeTag::findType(itRecData.second.first);
               if (datumType == eventsetup::TypeTag()) {
                 //not found
                 throw cms::Exception("ESPreferWrongDataType")
                     << "The es_prefer statement for type=" << itInfo.first.type_ << " label=\"" << itInfo.first.label_
                     << "\" has the unknown data type \"" << itRecData.second.first << "\""
                     << "\n Please check spelling";
               }
               eventsetup::DataKey datumKey(datumType, itRecData.second.second.c_str());
 
               //Does the proxyprovider make this?
               std::shared_ptr<DataProxyProvider> proxyProv = recordProviderForKey.proxyProvider(*itProxyProv);
               unsigned int iovIndex = 0;  // Doesn't matter which index is picked, at least 1 should always exist
               const DataProxyProvider::KeyedProxies& keyedProxies = proxyProv->keyedProxies(recordKey, iovIndex);
               if (!keyedProxies.contains(datumKey)) {
                 throw cms::Exception("ESPreferWrongData")
                     << "The es_prefer statement for type=" << itInfo.first.type_ << " label=\"" << itInfo.first.label_
                     << "\" specifies the data item \n"
                     << "  type=\"" << itRecData.second.first << "\" label=\"" << itRecData.second.second << "\""
                     << "  which is not provided.  Please check spelling.";
               }
 
               EventSetupRecordProvider::DataToPreferredProviderMap& dataToProviderMap =
                   (*recordToPreferred_)[recordKey];
               //has another provider already been specified?
               if (dataToProviderMap.end() != dataToProviderMap.find(datumKey)) {
                 EventSetupRecordProvider::DataToPreferredProviderMap::iterator itFind =
                     dataToProviderMap.find(datumKey);
                 throw cms::Exception("ESPreferConflict")
                     << "Two providers have been set to be preferred for\n"
                     << datumKey.type().name() << " \"" << datumKey.name().value() << "\""
                     << "\n the providers are "
                     << "\n 1) type=" << itFind->second.type_ << " label=\"" << itFind->second.label_ << "\""
                     << "\n 2) type=" << itProxyProv->type_ << " label=\"" << itProxyProv->label_ << "\""
                     << "\nPlease modify configuration so only one is preferred";
               }
               dataToProviderMap.insert(std::make_pair(datumKey, *itProxyProv));
             }
           }
         }
       }
     }

bool edm::eventsetup::EventSetupProvider::doRecordsMatch	(	EventSetupProvider &	precedingESProvider,
		EventSetupRecordKey const &	eventSetupRecordKey,
		std::map< EventSetupRecordKey, bool > &	allComponentsMatch,
		EventSetupsController const &	esController
	)

Definition at line 539 of file EventSetupProvider.cc.

References edm::eventsetup::EventSetupRecordProvider::dependentRecords(), fillReferencedDataKeys(), edm::eventsetup::EventSetupsController::isMatchingESProducer(), edm::eventsetup::EventSetupsController::isMatchingESSource(), edm::match(), recordsWithALooperProxy_, recordToFinders_, referencedDataKeys_, findQualityFiles::size, subProcessIndex_, and tryToGetRecordProvider().

Referenced by checkESProducerSharing().

                                                                                        {
       // first check if this record matches. If not just return false
 
       // then find the directly dependent records and iterate over them
       // recursively call this function on them. If they return false
       // set allComponentsMatch to false for them and return false.
       // if they all return true then set allComponents to true
       // and return true.
 
       if (precedingESProvider.recordsWithALooperProxy_->find(eventSetupRecordKey) !=
           precedingESProvider.recordsWithALooperProxy_->end()) {
         return false;
       }
 
       if ((*recordToFinders_)[eventSetupRecordKey].size() !=
           (*precedingESProvider.recordToFinders_)[eventSetupRecordKey].size()) {
         return false;
       }
 
       for (auto const& finder : (*recordToFinders_)[eventSetupRecordKey]) {
         ParameterSetID const& psetID = finder->descriptionForFinder().pid_;
         bool itMatches =
             esController.isMatchingESSource(psetID, subProcessIndex_, precedingESProvider.subProcessIndex_);
         if (!itMatches) {
           return false;
         }
       }
 
       fillReferencedDataKeys(eventSetupRecordKey);
       precedingESProvider.fillReferencedDataKeys(eventSetupRecordKey);
 
       std::map<DataKey, ComponentDescription const*> const& dataItems = (*referencedDataKeys_)[eventSetupRecordKey];
 
       std::map<DataKey, ComponentDescription const*> const& precedingDataItems =
           (*precedingESProvider.referencedDataKeys_)[eventSetupRecordKey];
 
       if (dataItems.size() != precedingDataItems.size()) {
         return false;
       }
 
       for (auto const& dataItem : dataItems) {
         auto precedingDataItem = precedingDataItems.find(dataItem.first);
         if (precedingDataItem == precedingDataItems.end()) {
           return false;
         }
         if (dataItem.second->pid_ != precedingDataItem->second->pid_) {
           return false;
         }
         // Check that the configurations match exactly for the ESProducers
         // (We already checked the ESSources above and there should not be
         // any loopers)
         if (!dataItem.second->isSource_ && !dataItem.second->isLooper_) {
           bool itMatches = esController.isMatchingESProducer(
               dataItem.second->pid_, subProcessIndex_, precedingESProvider.subProcessIndex_);
           if (!itMatches) {
             return false;
           }
         }
       }
       EventSetupRecordProvider* recProvider = tryToGetRecordProvider(eventSetupRecordKey);
       if (recProvider != nullptr) {
         std::set<EventSetupRecordKey> dependentRecords = recProvider->dependentRecords();
         for (auto const& dependentRecord : dependentRecords) {
           auto iter = allComponentsMatch.find(dependentRecord);
           if (iter != allComponentsMatch.end()) {
             if (iter->second) {
               continue;
             } else {
               return false;
             }
           }
           bool match = doRecordsMatch(precedingESProvider, dependentRecord, allComponentsMatch, esController);
           allComponentsMatch[dependentRecord] = match;
           if (!match)
             return false;
         }
       }
       return true;
     }

bool edm::eventsetup::EventSetupProvider::doWeNeedToWaitForIOVsToFinish ( IOVSyncValue const & iValue ) const

Definition at line 714 of file EventSetupProvider.cc.

References recordProviders_.

                                                                                            {
       for (auto& recProvider : recordProviders_) {
         if (recProvider->doWeNeedToWaitForIOVsToFinish(iValue)) {
           return true;
         }
       }
       return false;
     }

std::shared_ptr< const EventSetupImpl > edm::eventsetup::EventSetupProvider::eventSetupForInstance	(	IOVSyncValue const &	iValue,
		bool &	newEventSetupImpl
	)

Definition at line 675 of file EventSetupProvider.cc.

References eventSetupImpl_, edm::get_underlying_safe(), DetStateFilter::Invalid, recordKeys_, and recordProviders_.

                                                                                                              {
       using IntervalStatus = EventSetupRecordProvider::IntervalStatus;
 
       // It is important to understand that eventSetupForInstance is a function
       // where only one call is executing at a time (not multiple calls running
       // concurrently). These calls are made in the order determined by the
       // InputSource. One invocation completes and returns before another starts.
 
       bool needNewEventSetupImpl = false;
       if (eventSetupImpl_.get() == nullptr) {
         needNewEventSetupImpl = true;
       } else {
         for (auto& recProvider : recordProviders_) {
           if (recProvider->intervalStatus() == IntervalStatus::Invalid) {
             if (eventSetupImpl_->validRecord(recProvider->key())) {
               needNewEventSetupImpl = true;
             }
           } else {
             if (recProvider->newIntervalForAnySubProcess()) {
               needNewEventSetupImpl = true;
             }
           }
         }
       }
 
       if (needNewEventSetupImpl) {
         //cannot use make_shared because constructor is private
         eventSetupImpl_ = std::shared_ptr<EventSetupImpl>(new EventSetupImpl());
         newEventSetupImpl = true;
         eventSetupImpl_->setKeyIters(recordKeys_.begin(), recordKeys_.end());
 
         for (auto& recProvider : recordProviders_) {
           recProvider->setEventSetupImpl(eventSetupImpl_.get());
         }
       }
       return get_underlying_safe(eventSetupImpl_);
     }

EventSetupImpl const& edm::eventsetup::EventSetupProvider::eventSetupImpl ( ) const

inline

Definition at line 77 of file EventSetupProvider.h.

References eventSetupImpl_.

77 { return *eventSetupImpl_; }

edm::eventsetup::EventSetupProvider::eventSetupImpl_

propagate_const< std::shared_ptr< EventSetupImpl > > eventSetupImpl_

Definition: EventSetupProvider.h:140

void edm::eventsetup::EventSetupProvider::fillKeys ( std::set< EventSetupRecordKey > & keys ) const

Definition at line 749 of file EventSetupProvider.cc.

References recordProviders_.

                                                                              {
       for (auto const& recProvider : recordProviders_) {
         keys.insert(recProvider->key());
       }
     }

void edm::eventsetup::EventSetupProvider::fillRecordsNotAllowingConcurrentIOVs ( std::set< EventSetupRecordKey > & recordsNotAllowingConcurrentIOVs ) const

Definition at line 655 of file EventSetupProvider.cc.

References dataProviders_.

Referenced by edm::eventsetup::NumberOfConcurrentIOVs::fillRecordsNotAllowingConcurrentIOVs().

                                                                              {
       for (auto const& dataProxyProvider : *dataProviders_) {
         dataProxyProvider->fillRecordsNotAllowingConcurrentIOVs(recordsNotAllowingConcurrentIOVs);
       }
     }

void edm::eventsetup::EventSetupProvider::fillReferencedDataKeys ( EventSetupRecordKey const & eventSetupRecordKey )

Definition at line 622 of file EventSetupProvider.cc.

References edm::eventsetup::EventSetupRecordProvider::fillReferencedDataKeys(), referencedDataKeys_, and tryToGetRecordProvider().

Referenced by doRecordsMatch().

                                                                                                   {
       if (referencedDataKeys_->find(eventSetupRecordKey) != referencedDataKeys_->end())
         return;
 
       EventSetupRecordProvider* recProvider = tryToGetRecordProvider(eventSetupRecordKey);
       if (recProvider == nullptr) {
         (*referencedDataKeys_)[eventSetupRecordKey];
         return;
       }
       recProvider->fillReferencedDataKeys((*referencedDataKeys_)[eventSetupRecordKey]);
     }

void edm::eventsetup::EventSetupProvider::finishConfiguration	(	NumberOfConcurrentIOVs const &	numberOfConcurrentIOVs,
		bool &	hasNonconcurrentFinder
	)

Definition at line 233 of file EventSetupProvider.cc.

References activityRegistry_, edm::eventsetup::EventSetupRecordProvider::add(), edm::eventsetup::EventSetupRecordProvider::addFinder(), dataProviders_, determinePreferred(), HLT_FULL_cff::distance, finders_, dqmdumpme::indices, insert(), submitPVResolutionJobs::key, cuda_std::lower_bound(), mustFinishConfiguration_, edm::eventsetup::NumberOfConcurrentIOVs::numberOfConcurrentIOVs(), psetIDToRecordKey_, recordKeys_, recordProviders_, recordsToProxyIndices(), recordsWithALooperProxy_, recordToFinders_, recordToPreferred_, AlCaHLTBitMon_QueryRunRegistry::string, and tryToGetRecordProvider().

                                                                                {
       //we delayed adding finders to the system till here so that everything would be loaded first
       recordToFinders_->clear();
       for (auto& finder : *finders_) {
         if (!finder->concurrentFinder()) {
           hasNonconcurrentFinder = true;
         }
 
         const std::set<EventSetupRecordKey> recordsUsing = finder->findingForRecords();
 
         for (auto const& key : recordsUsing) {
           (*recordToFinders_)[key].push_back(finder);
 
           EventSetupRecordProvider* recProvider = tryToGetRecordProvider(key);
           if (recProvider == nullptr) {
             bool printInfoMsg = true;
             unsigned int nConcurrentIOVs = numberOfConcurrentIOVs.numberOfConcurrentIOVs(key, printInfoMsg);
 
             //create a provider for this record
             insert(key, std::make_unique<EventSetupRecordProvider>(key, activityRegistry_, nConcurrentIOVs));
             recProvider = tryToGetRecordProvider(key);
           }
           recProvider->addFinder(finder);
         }
       }
       //we've transfered our ownership so this is no longer needed
       finders_.reset();
 
       //Now handle providers since sources can also be finders and the sources can delay registering
       // their Records and therefore could delay setting up their Proxies
       psetIDToRecordKey_->clear();
       for (auto& dataProxyProvider : *dataProviders_) {
         ParameterSetIDHolder psetID(dataProxyProvider->description().pid_);
 
         const std::set<EventSetupRecordKey> recordsUsing = dataProxyProvider->usingRecords();
         for (auto const& key : recordsUsing) {
           unsigned int nConcurrentIOVs = numberOfConcurrentIOVs.numberOfConcurrentIOVs(key);
           dataProxyProvider->createKeyedProxies(key, nConcurrentIOVs);
 
           if (dataProxyProvider->description().isLooper_) {
             recordsWithALooperProxy_->insert(key);
           }
 
           (*psetIDToRecordKey_)[psetID].insert(key);
 
           EventSetupRecordProvider* recProvider = tryToGetRecordProvider(key);
           if (recProvider == nullptr) {
             bool printInfoMsg = true;
             nConcurrentIOVs = numberOfConcurrentIOVs.numberOfConcurrentIOVs(key, printInfoMsg);
             //create a provider for this record
             insert(key, std::make_unique<EventSetupRecordProvider>(key, activityRegistry_, nConcurrentIOVs));
             recProvider = tryToGetRecordProvider(key);
           }
           recProvider->add(dataProxyProvider);
         }
       }
 
       //used for the case where no preferred Providers have been specified for the Record
       static const EventSetupRecordProvider::DataToPreferredProviderMap kEmptyMap;
 
       determinePreferred();
 
       //For each Provider, find all the Providers it depends on.  If a dependent Provider
       // can not be found pass in an empty list
       //CHANGE: now allow for missing Providers
       for (auto& itRecordProvider : recordProviders_) {
         const EventSetupRecordProvider::DataToPreferredProviderMap* preferredInfo = &kEmptyMap;
         RecordToPreferred::const_iterator itRecordFound = recordToPreferred_->find(itRecordProvider->key());
         if (itRecordFound != recordToPreferred_->end()) {
           preferredInfo = &(itRecordFound->second);
         }
         //Give it our list of preferred
         itRecordProvider->usePreferred(*preferredInfo);
 
         std::set<EventSetupRecordKey> records = itRecordProvider->dependentRecords();
         if (!records.empty()) {
           std::string missingRecords;
           std::vector<std::shared_ptr<EventSetupRecordProvider>> depProviders;
           depProviders.reserve(records.size());
           bool foundAllProviders = true;
           for (auto const& key : records) {
             auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), key);
             if (lb == recordKeys_.end() || key != *lb) {
               foundAllProviders = false;
               if (missingRecords.empty()) {
                 missingRecords = key.name();
               } else {
                 missingRecords += ", ";
                 missingRecords += key.name();
               }
             } else {
               auto index = std::distance(recordKeys_.begin(), lb);
               depProviders.push_back(recordProviders_[index]);
             }
           }
 
           if (!foundAllProviders) {
             edm::LogInfo("EventSetupDependency")
                 << "The EventSetup record " << itRecordProvider->key().name() << " depends on at least one Record \n ("
                 << missingRecords
                 << ") which is not present in the job."
                    "\n This may lead to an exception begin thrown during event processing.\n If no exception occurs "
                    "during the job than it is usually safe to ignore this message.";
 
             //depProviders.clear();
             //NOTE: should provide a warning
           }
 
           itRecordProvider->setDependentProviders(depProviders);
         }
       }
 
       auto indices = recordsToProxyIndices();
       for (auto& provider : *dataProviders_) {
         provider->updateLookup(indices);
       }
       dataProviders_.reset();
 
       mustFinishConfiguration_ = false;
     }

void edm::eventsetup::EventSetupProvider::forceCacheClear ( )

Used when testing that all code properly updates on IOV changes of all Records.

Definition at line 388 of file EventSetupProvider.cc.

References recordProviders_.

Referenced by ~EventSetupProvider().

                                              {
       for (auto& recProvider : recordProviders_) {
         if (recProvider) {
           recProvider->resetProxies();
         }
       }
     }

void edm::eventsetup::EventSetupProvider::insert	(	EventSetupRecordKey const &	iKey,
		std::unique_ptr< EventSetupRecordProvider >	iProvider
	)

private

Definition at line 78 of file EventSetupProvider.cc.

References HLT_FULL_cff::distance, cuda_std::lower_bound(), eostools::move(), recordKeys_, and recordProviders_.

Referenced by BeautifulSoup.PageElement::_invert(), SequenceTypes.Schedule::_replaceIfHeldDirectly(), addRecord(), and finishConfiguration().

                                                                                        {
       auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), iKey);
       auto index = std::distance(recordKeys_.begin(), lb);
       if (lb == recordKeys_.end() || iKey != *lb) {
         recordKeys_.insert(lb, iKey);
         recordProviders_.insert(recordProviders_.begin() + index, std::move(iProvider));
       } else {
         recordProviders_[index] = std::move(iProvider);
       }
     }

void edm::eventsetup::EventSetupProvider::logInfoWhenSharing ( ParameterSet const & iConfiguration )

static

Definition at line 770 of file EventSetupProvider.cc.

References edm::ParameterSet::getParameter(), label, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by checkESProducerSharing().

                                                                                   {
       std::string edmtype = iConfiguration.getParameter<std::string>("@module_edm_type");
       std::string modtype = iConfiguration.getParameter<std::string>("@module_type");
       std::string label = iConfiguration.getParameter<std::string>("@module_label");
       edm::LogVerbatim("EventSetupSharing")
           << "Sharing " << edmtype << ": class=" << modtype << " label='" << label << "'";
     }

EventSetupProvider const& edm::eventsetup::EventSetupProvider::operator= ( EventSetupProvider const & )

delete

std::set< ComponentDescription > edm::eventsetup::EventSetupProvider::proxyProviderDescriptions ( ) const

Definition at line 723 of file EventSetupProvider.cc.

References ztail::d, dataProviders_, AlCaHLTBitMon_ParallelJobs::p, and recordProviders_.

                                                                                      {
       typedef std::set<ComponentDescription> Set;
       Set descriptions;
 
       for (auto const& recProvider : recordProviders_) {
         auto const& d = recProvider->proxyProviderDescriptions();
         descriptions.insert(d.begin(), d.end());
       }
       if (dataProviders_.get()) {
         for (auto const& p : *dataProviders_) {
           descriptions.insert(p->description());
         }
       }
 
       return descriptions;
     }

std::shared_ptr< EventSetupRecordProvider > & edm::eventsetup::EventSetupProvider::recordProvider ( const EventSetupRecordKey & iKey )

private

Definition at line 59 of file EventSetupProvider.cc.

References HLT_FULL_cff::distance, Exception, cuda_std::lower_bound(), recordKeys_, and recordProviders_.

Referenced by checkESProducerSharing(), determinePreferred(), and replaceExisting().

                                                                                                                {
       auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), iKey);
       if (lb == recordKeys_.end() || iKey != *lb) {
         throw cms::Exception("LogicError") << "EventSetupProvider::recordProvider Could not find key\n"
                                            << "Should be impossible. Please contact Framework developer.\n";
       }
       auto index = std::distance(recordKeys_.begin(), lb);
       return recordProviders_[index];
     }

ESRecordsToProxyIndices edm::eventsetup::EventSetupProvider::recordsToProxyIndices ( ) const

Definition at line 755 of file EventSetupProvider.cc.

References edm::eventsetup::ESRecordsToProxyIndices::dataKeysInRecord(), recordKeys_, recordProviders_, and runTheMatrix::ret.

Referenced by finishConfiguration().

                                                                             {
       ESRecordsToProxyIndices ret(recordKeys_);
 
       unsigned int index = 0;
       for (const auto& provider : recordProviders_) {
         index = ret.dataKeysInRecord(
             index, provider->key(), provider->registeredDataKeys(), provider->componentsForRegisteredDataKeys());
       }
 
       return ret;
     }

void edm::eventsetup::EventSetupProvider::replaceExisting ( std::shared_ptr< DataProxyProvider > dataProxyProvider )

Definition at line 98 of file EventSetupProvider.cc.

References submitPVResolutionJobs::key, and recordProvider().

Referenced by edm::eventsetup::ModuleMakerTraits::replaceExisting().

                                                                                                {
       ParameterSetIDHolder psetID(dataProxyProvider->description().pid_);
       std::set<EventSetupRecordKey> const& keysForPSetID = (*psetIDToRecordKey_)[psetID];
       for (auto const& key : keysForPSetID) {
         recordProvider(key)->resetProxyProvider(psetID, dataProxyProvider);
       }
     }

void edm::eventsetup::EventSetupProvider::resetRecordPlusDependentRecords ( EventSetupRecordKey const & iKey )

Used when we need to force a Record to reset all its proxies.

Definition at line 371 of file EventSetupProvider.cc.

References ztail::d, edm::eventsetup::findDependents(), recordProviders_, edm::eventsetup::EventSetupRecordProvider::resetProxies(), tryToGetRecordProvider(), and tier0::unique().

Referenced by edm::EDLooperBase::prepareForNextLoop().

                                                                                             {
       EventSetupRecordProvider* recProvider = tryToGetRecordProvider(iKey);
       if (recProvider == nullptr) {
         return;
       }
 
       std::vector<std::shared_ptr<EventSetupRecordProvider>> dependents;
       findDependents(iKey, recordProviders_.begin(), recordProviders_.end(), dependents);
 
       dependents.erase(std::unique(dependents.begin(), dependents.end()), dependents.end());
 
       recProvider->resetProxies();
       for (auto& d : dependents) {
         d->resetProxies();
       }
     }

void edm::eventsetup::EventSetupProvider::resetRecordToProxyPointers ( )

Definition at line 634 of file EventSetupProvider.cc.

References recordProviders_, and recordToPreferred_.

                                                         {
       for (auto const& recProvider : recordProviders_) {
         static const EventSetupRecordProvider::DataToPreferredProviderMap kEmptyMap;
         const EventSetupRecordProvider::DataToPreferredProviderMap* preferredInfo = &kEmptyMap;
         RecordToPreferred::const_iterator itRecordFound = recordToPreferred_->find(recProvider->key());
         if (itRecordFound != recordToPreferred_->end()) {
           preferredInfo = &(itRecordFound->second);
         }
         recProvider->resetRecordToProxyPointers(*preferredInfo);
       }
     }

void edm::eventsetup::EventSetupProvider::setAllValidityIntervals ( const IOVSyncValue & iValue )

Set the validity intervals in all EventSetupRecordProviders.

Definition at line 662 of file EventSetupProvider.cc.

References recordProviders_.

                                                                                {
       // First loop sets a flag that helps us to not duplicate calls to the
       // same EventSetupRecordProvider setting the IOVs. Dependent records
       // can cause duplicate calls without this protection.
       for (auto& recProvider : recordProviders_) {
         recProvider->initializeForNewSyncValue();
       }
 
       for (auto& recProvider : recordProviders_) {
         recProvider->setValidityIntervalFor(iValue);
       }
     }

void edm::eventsetup::EventSetupProvider::setPreferredProviderInfo ( PreferredProviderInfo const & iInfo )

Definition at line 745 of file EventSetupProvider.cc.

References preferredProviderInfo_.

                                                                                         {
       preferredProviderInfo_ = std::make_unique<PreferredProviderInfo>(iInfo);
     }

unsigned edm::eventsetup::EventSetupProvider::subProcessIndex ( ) const

inline

Definition at line 108 of file EventSetupProvider.h.

References subProcessIndex_.

Referenced by checkESProducerSharing().

108 { return subProcessIndex_; }

edm::eventsetup::EventSetupProvider::subProcessIndex_

unsigned subProcessIndex_

Definition: EventSetupProvider.h:139

EventSetupRecordProvider * edm::eventsetup::EventSetupProvider::tryToGetRecordProvider ( const EventSetupRecordKey & iKey )

Definition at line 69 of file EventSetupProvider.cc.

References HLT_FULL_cff::distance, cuda_std::lower_bound(), recordKeys_, and recordProviders_.

Referenced by doRecordsMatch(), fillReferencedDataKeys(), finishConfiguration(), and resetRecordPlusDependentRecords().

                                                                                                         {
       auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), iKey);
       if (lb == recordKeys_.end() || iKey != *lb) {
         return nullptr;
       }
       auto index = std::distance(recordKeys_.begin(), lb);
       return recordProviders_[index].get();
     }

Member Data Documentation

ActivityRegistry const* edm::eventsetup::EventSetupProvider::activityRegistry_

private

Definition at line 136 of file EventSetupProvider.h.

Referenced by add(), and finishConfiguration().

std::unique_ptr<std::vector<std::shared_ptr<DataProxyProvider> > > edm::eventsetup::EventSetupProvider::dataProviders_

private

Definition at line 146 of file EventSetupProvider.h.

Referenced by add(), fillRecordsNotAllowingConcurrentIOVs(), finishConfiguration(), and proxyProviderDescriptions().

propagate_const<std::shared_ptr<EventSetupImpl> > edm::eventsetup::EventSetupProvider::eventSetupImpl_

private

Definition at line 140 of file EventSetupProvider.h.

Referenced by addRecord(), eventSetupForInstance(), and eventSetupImpl().

std::unique_ptr<std::vector<std::shared_ptr<EventSetupRecordIntervalFinder> > > edm::eventsetup::EventSetupProvider::finders_

private

Definition at line 145 of file EventSetupProvider.h.

Referenced by add(), and finishConfiguration().

bool edm::eventsetup::EventSetupProvider::mustFinishConfiguration_

private

Definition at line 138 of file EventSetupProvider.h.

Referenced by finishConfiguration().

std::unique_ptr<PreferredProviderInfo> edm::eventsetup::EventSetupProvider::preferredProviderInfo_

private

Definition at line 144 of file EventSetupProvider.h.

Referenced by clearInitializationData(), determinePreferred(), and setPreferredProviderInfo().

std::unique_ptr<std::map<ParameterSetIDHolder, std::set<EventSetupRecordKey> > > edm::eventsetup::EventSetupProvider::psetIDToRecordKey_

private

Definition at line 150 of file EventSetupProvider.h.

Referenced by checkESProducerSharing(), clearInitializationData(), and finishConfiguration().

RecordKeys edm::eventsetup::EventSetupProvider::recordKeys_

private

Definition at line 131 of file EventSetupProvider.h.

Referenced by addRecord(), eventSetupForInstance(), finishConfiguration(), insert(), recordProvider(), recordsToProxyIndices(), and tryToGetRecordProvider().

RecordProviders edm::eventsetup::EventSetupProvider::recordProviders_

private

Definition at line 134 of file EventSetupProvider.h.

Referenced by checkESProducerSharing(), determinePreferred(), doWeNeedToWaitForIOVsToFinish(), eventSetupForInstance(), fillKeys(), finishConfiguration(), forceCacheClear(), insert(), proxyProviderDescriptions(), recordProvider(), recordsToProxyIndices(), resetRecordPlusDependentRecords(), resetRecordToProxyPointers(), setAllValidityIntervals(), and tryToGetRecordProvider().

std::unique_ptr<std::set<EventSetupRecordKey> > edm::eventsetup::EventSetupProvider::recordsWithALooperProxy_

private

Definition at line 152 of file EventSetupProvider.h.

Referenced by clearInitializationData(), doRecordsMatch(), and finishConfiguration().

std::unique_ptr<std::map<EventSetupRecordKey, std::vector<std::shared_ptr<EventSetupRecordIntervalFinder> > > > edm::eventsetup::EventSetupProvider::recordToFinders_

private

Definition at line 149 of file EventSetupProvider.h.

Referenced by clearInitializationData(), doRecordsMatch(), and finishConfiguration().

std::unique_ptr<std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription> > > edm::eventsetup::EventSetupProvider::recordToPreferred_

private

Definition at line 151 of file EventSetupProvider.h.

Referenced by clearInitializationData(), determinePreferred(), finishConfiguration(), and resetRecordToProxyPointers().

std::unique_ptr<std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription const*> > > edm::eventsetup::EventSetupProvider::referencedDataKeys_

private

Definition at line 147 of file EventSetupProvider.h.

Referenced by clearInitializationData(), doRecordsMatch(), and fillReferencedDataKeys().

unsigned edm::eventsetup::EventSetupProvider::subProcessIndex_

private

Definition at line 139 of file EventSetupProvider.h.

Referenced by checkESProducerSharing(), doRecordsMatch(), and subProcessIndex().

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation