edm::eventsetup::EventSetupProvider Class Reference

#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

DataKeyInfo

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

Definition at line 54 of file EventSetupProvider.h.

DataLabel

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

Definition at line 53 of file EventSetupProvider.h.

DataType

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

Definition at line 52 of file EventSetupProvider.h.

PreferredProviderInfo

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

Definition at line 56 of file EventSetupProvider.h.

RecordKeys

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

private

Definition at line 130 of file EventSetupProvider.h.

RecordName

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

Definition at line 51 of file EventSetupProvider.h.

RecordProviders

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

private

Definition at line 133 of file EventSetupProvider.h.

RecordToDataMap

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

Definition at line 55 of file EventSetupProvider.h.

Constructor & Destructor Documentation

EventSetupProvider() [1/2]

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

Definition at line 40 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>) {}

EventSetupProvider() [2/2]

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

delete

~EventSetupProvider()

edm::eventsetup::EventSetupProvider::~EventSetupProvider

(

)

Definition at line 56 of file EventSetupProvider.cc.

{ forceCacheClear(); }

References forceCacheClear().

Member Function Documentation

add() [1/2]

void edm::eventsetup::EventSetupProvider::add

(

std::shared_ptr< DataProxyProvider >

iProvider

)

Definition at line 89 of file EventSetupProvider.cc.

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

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

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().

add() [2/2]

void edm::eventsetup::EventSetupProvider::add

(

std::shared_ptr< EventSetupRecordIntervalFinder >

iFinder

)

Definition at line 102 of file EventSetupProvider.cc.

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

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

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

addRecord()

void edm::eventsetup::EventSetupProvider::addRecord

(

const EventSetupRecordKey &

iKey

)

Intended for use only in tests.

Definition at line 736 of file EventSetupProvider.cc.

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

References eventSetupImpl_, insert(), and recordKeys_.

checkESProducerSharing()

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

Definition at line 392 of file EventSetupProvider.cc.

                                             {
      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);
          }
        }
      }
    }

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

clearInitializationData()

void edm::eventsetup::EventSetupProvider::clearInitializationData

(

)

Definition at line 642 of file EventSetupProvider.cc.

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

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

determinePreferred()

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

private

Definition at line 157 of file EventSetupProvider.cc.

                                                {
      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));
            }
          }
        }
      }
    }

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().

doRecordsMatch()

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

Definition at line 535 of file EventSetupProvider.cc.

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

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

Referenced by checkESProducerSharing().

doWeNeedToWaitForIOVsToFinish()

bool edm::eventsetup::EventSetupProvider::doWeNeedToWaitForIOVsToFinish

(

IOVSyncValue const &

iValue

)

const

Definition at line 710 of file EventSetupProvider.cc.

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

References recordProviders_.

eventSetupForInstance()

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

Definition at line 671 of file EventSetupProvider.cc.

                                                                                                             {
      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_);
    }

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

eventSetupImpl()

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

inline

Definition at line 77 of file EventSetupProvider.h.

{ return *eventSetupImpl_; }

References eventSetupImpl_.

fillKeys()

void edm::eventsetup::EventSetupProvider::fillKeys

(

std::set< EventSetupRecordKey > &

keys

)

const

Definition at line 745 of file EventSetupProvider.cc.

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

References relativeConstraints::keys, and recordProviders_.

fillRecordsNotAllowingConcurrentIOVs()

void edm::eventsetup::EventSetupProvider::fillRecordsNotAllowingConcurrentIOVs

(

std::set< EventSetupRecordKey > &

recordsNotAllowingConcurrentIOVs

)

const

Definition at line 651 of file EventSetupProvider.cc.

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

References dataProviders_.

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

fillReferencedDataKeys()

void edm::eventsetup::EventSetupProvider::fillReferencedDataKeys

(

EventSetupRecordKey const &

eventSetupRecordKey

)

Definition at line 618 of file EventSetupProvider.cc.

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

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

Referenced by doRecordsMatch().

finishConfiguration()

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

Definition at line 229 of file EventSetupProvider.cc.

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

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

forceCacheClear()

void edm::eventsetup::EventSetupProvider::forceCacheClear

(

)

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

Definition at line 384 of file EventSetupProvider.cc.

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

References recordProviders_.

Referenced by ~EventSetupProvider().

insert()

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

private

Definition at line 77 of file EventSetupProvider.cc.

                                                                                       {
      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);
      }
    }

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

Referenced by addRecord(), and finishConfiguration().

logInfoWhenSharing()

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

static

Definition at line 766 of file EventSetupProvider.cc.

                                                                                  {
      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 << "'";
    }

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

Referenced by checkESProducerSharing().

operator=()

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

delete

proxyProviderDescriptions()

std::set< ComponentDescription > edm::eventsetup::EventSetupProvider::proxyProviderDescriptions

(

)

const

Definition at line 719 of file EventSetupProvider.cc.

                                                                                     {
      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;
    }

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

recordProvider()

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

private

Definition at line 58 of file EventSetupProvider.cc.

                                                                                                               {
      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];
    }

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

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

recordsToProxyIndices()

ESRecordsToProxyIndices edm::eventsetup::EventSetupProvider::recordsToProxyIndices

(

)

const

Definition at line 751 of file EventSetupProvider.cc.

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

References recordKeys_, recordProviders_, and runTheMatrix::ret.

Referenced by finishConfiguration().

replaceExisting()

void edm::eventsetup::EventSetupProvider::replaceExisting

(

std::shared_ptr< DataProxyProvider >

dataProxyProvider

)

Definition at line 94 of file EventSetupProvider.cc.

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

References crabWrapper::key, and recordProvider().

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

resetRecordPlusDependentRecords()

void edm::eventsetup::EventSetupProvider::resetRecordPlusDependentRecords

(

EventSetupRecordKey const &

iKey

)

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

Definition at line 367 of file EventSetupProvider.cc.

                                                                                            {
      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();
      }
    }

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

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

resetRecordToProxyPointers()

void edm::eventsetup::EventSetupProvider::resetRecordToProxyPointers

(

)

Definition at line 630 of file EventSetupProvider.cc.

                                                        {
      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);
      }
    }

References recordProviders_, and recordToPreferred_.

setAllValidityIntervals()

void edm::eventsetup::EventSetupProvider::setAllValidityIntervals

(

const IOVSyncValue &

iValue

)

Set the validity intervals in all EventSetupRecordProviders.

Definition at line 658 of file EventSetupProvider.cc.

                                                                               {
      // 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);
      }
    }

References recordProviders_.

setPreferredProviderInfo()

void edm::eventsetup::EventSetupProvider::setPreferredProviderInfo

(

PreferredProviderInfo const &

iInfo

)

Definition at line 741 of file EventSetupProvider.cc.

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

References preferredProviderInfo_.

subProcessIndex()

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

inline

Definition at line 108 of file EventSetupProvider.h.

{ return subProcessIndex_; }

References subProcessIndex_.

Referenced by checkESProducerSharing().

tryToGetRecordProvider()

EventSetupRecordProvider * edm::eventsetup::EventSetupProvider::tryToGetRecordProvider

(

const EventSetupRecordKey &

iKey

)

Definition at line 68 of file EventSetupProvider.cc.

                                                                                                        {
      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();
    }

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

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

Member Data Documentation

activityRegistry_

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

private

Definition at line 136 of file EventSetupProvider.h.

Referenced by finishConfiguration().

dataProviders_

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().

eventSetupImpl_

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().

finders_

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().

mustFinishConfiguration_

bool edm::eventsetup::EventSetupProvider::mustFinishConfiguration_

private

Definition at line 138 of file EventSetupProvider.h.

Referenced by finishConfiguration().

preferredProviderInfo_

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

private

Definition at line 144 of file EventSetupProvider.h.

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

psetIDToRecordKey_

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_

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_

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().

recordsWithALooperProxy_

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().

recordToFinders_

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().

recordToPreferred_

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().

referencedDataKeys_

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().

subProcessIndex_

unsigned edm::eventsetup::EventSetupProvider::subProcessIndex_

private

Definition at line 139 of file EventSetupProvider.h.

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