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	addRecordToEventSetup (EventSetupRecord &iRecord)
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)
EventSetup const &	eventSetup () const
EventSetup const &	eventSetupForInstance (IOVSyncValue const &)
	EventSetupProvider (unsigned subProcessIndex=0U, PreferredProviderInfo const *iInfo=0)
void	fillReferencedDataKeys (EventSetupRecordKey const &eventSetupRecordKey)
void	finishConfiguration ()
void	forceCacheClear ()
	Used when testing that all code properly updates on IOV changes of all Records. More...
std::set< ComponentDescription >	proxyProviderDescriptions () 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 ()
unsigned	subProcessIndex () const
virtual	~EventSetupProvider ()

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

Protected Member Functions
template<typename T >
void	insert (std::unique_ptr< T > iRecordProvider)

Private Types
typedef std::map< EventSetupRecordKey, std::shared_ptr< EventSetupRecordProvider > >	Providers

Private Member Functions
	EventSetupProvider (EventSetupProvider const &)=delete
void	insert (EventSetupRecordKey const &, std::unique_ptr< EventSetupRecordProvider >)
EventSetupProvider const &	operator= (EventSetupProvider const &)=delete

Private Attributes
std::unique_ptr< std::vector< std::shared_ptr< DataProxyProvider > > >	dataProviders_
EventSetup	eventSetup_
std::unique_ptr< std::vector< std::shared_ptr< EventSetupRecordIntervalFinder > > >	finders_
std::unique_ptr< EventSetupKnownRecordsSupplier >	knownRecordsSupplier_
bool	mustFinishConfiguration_
std::unique_ptr< PreferredProviderInfo >	preferredProviderInfo_
Providers	providers_
std::unique_ptr< std::map< ParameterSetIDHolder, std::set< EventSetupRecordKey > > >	psetIDToRecordKey_
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

Definition at line 50 of file EventSetupProvider.h.

Member Typedef Documentation

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

Definition at line 56 of file EventSetupProvider.h.

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

Definition at line 55 of file EventSetupProvider.h.

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

Definition at line 54 of file EventSetupProvider.h.

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

Definition at line 58 of file EventSetupProvider.h.

typedef std::map<EventSetupRecordKey, std::shared_ptr<EventSetupRecordProvider> > edm::eventsetup::EventSetupProvider::Providers

private

Definition at line 128 of file EventSetupProvider.h.

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

Definition at line 53 of file EventSetupProvider.h.

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

Definition at line 57 of file EventSetupProvider.h.

Constructor & Destructor Documentation

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

Referenced by insert().

EventSetupProvider::~EventSetupProvider ( )

virtual

Definition at line 87 of file EventSetupProvider.cc.

References edm::eventsetup::heterocontainer::insert(), and groupFilesInBlocks::temp.

{
}

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

privatedelete

Member Function Documentation

void EventSetupProvider::add

(

std::shared_ptr< DataProxyProvider >

iProvider

)

Definition at line 115 of file EventSetupProvider.cc.

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

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

void EventSetupProvider::add

(

std::shared_ptr< EventSetupRecordIntervalFinder >

iFinder

)

Definition at line 133 of file EventSetupProvider.cc.

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

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

void EventSetupProvider::addRecordToEventSetup

(

EventSetupRecord &

iRecord

)

Definition at line 735 of file EventSetupProvider.cc.

References edm::eventsetup::EventSetupRecord::setEventSetup().

Referenced by edm::eventsetup::EventSetupRecordProvider::addRecordTo(), and eventSetup().

                                                                   {
   iRecord.setEventSetup(&eventSetup_);
   eventSetup_.add(iRecord);
}

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

Definition at line 452 of file EventSetupProvider.cc.

References reco::get(), edm::eventsetup::EventSetupsController::getESProducerPSet(), edm::eventsetup::EventSetupsController::isFirstMatch(), edm::eventsetup::EventSetupsController::isLastMatch(), crabWrapper::key, edm::eventsetup::EventSetupsController::lookForMatches(), match(), providers_, muonDTDigis_cfi::pset, psetIDToRecordKey_, subProcessIndex(), and subProcessIndex_.

Referenced by eventSetup().

                                                                                {

   edm::LogVerbatim("EventSetupSharing") << "EventSetupProvider::checkESProducerSharing: Checking processes with SubProcess Indexes "
                                         << subProcessIndex() << " and " << precedingESProvider.subProcessIndex();

   if (referencedESProducers.empty()) {
      for (auto const& recordProvider : providers_) {
         recordProvider.second->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 (prefered 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) {
            std::shared_ptr<EventSetupRecordProvider> const& recordProvider = precedingESProvider.providers_[key];
            dataProxyProvider = recordProvider->proxyProvider(psetIDHolder);
            assert(dataProxyProvider);
            break;
         }

         std::set<EventSetupRecordKey> const& keysForPSetID2 = (*psetIDToRecordKey_)[psetIDHolder];
         for (auto const& key : keysForPSetID2) {
            std::shared_ptr<EventSetupRecordProvider> const& recordProvider = providers_[key];
            recordProvider->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 EventSetupProvider::clearInitializationData

(

)

Definition at line 725 of file EventSetupProvider.cc.

Referenced by eventSetup().

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

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

Definition at line 612 of file EventSetupProvider.cc.

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

Referenced by eventSetup().

                                                                              {
   // 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;
         }
      }
   }
   Providers::iterator itFound = providers_.find(eventSetupRecordKey);
   if (itFound != providers_.end()) {
      std::set<EventSetupRecordKey> dependentRecords = itFound->second->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;
}

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

inline

Definition at line 71 of file EventSetupProvider.h.

References add(), addRecordToEventSetup(), checkESProducerSharing(), clearInitializationData(), doRecordsMatch(), eventSetup_, fillReferencedDataKeys(), finishConfiguration(), forceCacheClear(), genParticles_cff::map, replaceExisting(), resetRecordPlusDependentRecords(), and resetRecordToProxyPointers().

{return eventSetup_;}

EventSetup const & EventSetupProvider::eventSetupForInstance

(

IOVSyncValue const &

)

Definition at line 744 of file EventSetupProvider.cc.

References edm::EventSetup::setIOVSyncValue().

{
   eventSetup_.setIOVSyncValue(iValue);

   eventSetup_.clear();

   // In a cmsRun job this does nothing because the EventSetupsController
   // will have already called finishConfiguration, but some tests will
   // call finishConfiguration here.
   if(mustFinishConfiguration_) {
      finishConfiguration();
   }

   for(Providers::iterator itProvider = providers_.begin(), itProviderEnd = providers_.end();
        itProvider != itProviderEnd;
        ++itProvider) {
      itProvider->second->addRecordToIfValid(*this, iValue);
   }   
   return eventSetup_;
}

void EventSetupProvider::fillReferencedDataKeys

(

EventSetupRecordKey const &

eventSetupRecordKey

)

Definition at line 697 of file EventSetupProvider.cc.

Referenced by doRecordsMatch(), and eventSetup().

                                                                                         {

   if (referencedDataKeys_->find(eventSetupRecordKey) != referencedDataKeys_->end()) return;

   auto recordProvider = providers_.find(eventSetupRecordKey);
   if (recordProvider == providers_.end()) {
      (*referencedDataKeys_)[eventSetupRecordKey];
      return;
   }
   if (recordProvider->second) {
      recordProvider->second->fillReferencedDataKeys((*referencedDataKeys_)[eventSetupRecordKey]);
   }
}

void EventSetupProvider::finishConfiguration

(

)

Definition at line 281 of file EventSetupProvider.cc.

References edm::eventsetup::determinePreferred(), edm::eventsetup::heterocontainer::insert(), instance, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by eventSetup().

{   
   //we delayed adding finders to the system till here so that everything would be loaded first
   recordToFinders_->clear();
   for(std::vector<std::shared_ptr<EventSetupRecordIntervalFinder> >::iterator itFinder=finders_->begin(),
       itEnd = finders_->end();
       itFinder != itEnd;
       ++itFinder) {
      typedef std::set<EventSetupRecordKey> Keys;
      const Keys recordsUsing = (*itFinder)->findingForRecords();
      
      for(Keys::const_iterator itKey = recordsUsing.begin(), itKeyEnd = recordsUsing.end();
          itKey != itKeyEnd;
          ++itKey) {
        (*recordToFinders_)[*itKey].push_back(*itFinder);
         Providers::iterator itFound = providers_.find(*itKey);
         if(providers_.end() == itFound) {
            //create a provider for this record
            insert(*itKey, EventSetupRecordProviderFactoryManager::instance().makeRecordProvider(*itKey));
            itFound = providers_.find(*itKey);
         }
         itFound->second->addFinder(*itFinder);
      }      
   }
   //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();
   typedef std::set<EventSetupRecordKey> Keys;
   for(std::vector<std::shared_ptr<DataProxyProvider> >::iterator itProvider=dataProviders_->begin(),
       itEnd = dataProviders_->end();
       itProvider != itEnd;
       ++itProvider) {
      
      ParameterSetIDHolder psetID((*itProvider)->description().pid_);

      const Keys recordsUsing = (*itProvider)->usingRecords();
      
      for(Keys::const_iterator itKey = recordsUsing.begin(), itKeyEnd = recordsUsing.end();
          itKey != itKeyEnd;
          ++itKey) {

         if ((*itProvider)->description().isLooper_) {
            recordsWithALooperProxy_->insert(*itKey);
         }

         (*psetIDToRecordKey_)[psetID].insert(*itKey);

         Providers::iterator itFound = providers_.find(*itKey);
         if(providers_.end() == itFound) {
            //create a provider for this record
            insert(*itKey, EventSetupRecordProviderFactoryManager::instance().makeRecordProvider(*itKey));
            itFound = providers_.find(*itKey);
         }
         itFound->second->add(*itProvider);
      }
   }
   dataProviders_.reset();
   
   //used for the case where no preferred Providers have been specified for the Record
   static const EventSetupRecordProvider::DataToPreferredProviderMap kEmptyMap;
   
   *recordToPreferred_ = determinePreferred(preferredProviderInfo_.get(),providers_);
   //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(Providers::iterator itProvider = providers_.begin(), itProviderEnd = providers_.end();
        itProvider != itProviderEnd;
        ++itProvider) {
      const EventSetupRecordProvider::DataToPreferredProviderMap* preferredInfo = &kEmptyMap;
      RecordToPreferred::const_iterator itRecordFound = recordToPreferred_->find(itProvider->first);
      if(itRecordFound != recordToPreferred_->end()) {
         preferredInfo = &(itRecordFound->second);
      }
      //Give it our list of preferred 
      itProvider->second->usePreferred(*preferredInfo);
      
      std::set<EventSetupRecordKey> records = itProvider->second->dependentRecords();
      if(!records.empty()) {
         std::string missingRecords;
         std::vector<std::shared_ptr<EventSetupRecordProvider> > depProviders;
         depProviders.reserve(records.size());
         bool foundAllProviders = true;
         for(std::set<EventSetupRecordKey>::iterator itRecord = records.begin(),
              itRecordEnd = records.end();
              itRecord != itRecordEnd;
              ++itRecord) {
            Providers::iterator itFound = providers_.find(*itRecord);
            if(itFound == providers_.end()) {
               foundAllProviders = false;
               if(missingRecords.empty()) {
                 missingRecords = itRecord->name();
               } else {
                 missingRecords += ", ";
                 missingRecords += itRecord->name();
               }
               //break;
            } else {
               depProviders.push_back(itFound->second);
            }
         }
         
         if(!foundAllProviders) {
            edm::LogInfo("EventSetupDependency")<<"The EventSetup record "<<itProvider->second->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
         }
          
         itProvider->second->setDependentProviders(depProviders);
      }
   }
   mustFinishConfiguration_ = false;
}

void EventSetupProvider::forceCacheClear

(

)

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

Definition at line 442 of file EventSetupProvider.cc.

Referenced by eventSetup().

{
   for(Providers::iterator it=providers_.begin(), itEnd = providers_.end();
       it != itEnd;
       ++it) {
      it->second->resetProxies();
   }
}

template<typename T >

void edm::eventsetup::EventSetupProvider::insert ( std::unique_ptr< T >  iRecordProvider )

inlineprotected

Definition at line 111 of file EventSetupProvider.h.

References EventSetupProvider(), edm::eventsetup::heterocontainer::makeKey(), eostools::move(), operator=(), and groupFilesInBlocks::temp.

                                                       {
            std::unique_ptr<EventSetupRecordProvider> temp(iRecordProvider.release());
            insert(eventsetup::heterocontainer::makeKey<
                    typename T::RecordType,
                       eventsetup::EventSetupRecordKey>(),
                    std::move(temp));
         }

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

private

void EventSetupProvider::logInfoWhenSharing ( ParameterSet const &  iConfiguration )

static

Definition at line 787 of file EventSetupProvider.cc.

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

Referenced by subProcessIndex().

                                                                              {

   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 &  )

privatedelete

Referenced by insert().

std::set< ComponentDescription > EventSetupProvider::proxyProviderDescriptions

(

)

const

Definition at line 766 of file EventSetupProvider.cc.

References edmIntegrityCheck::d, and AlCaHLTBitMon_ParallelJobs::p.

{
   typedef std::set<ComponentDescription> Set;
   Set descriptions;

   for(auto const& p: providers_) {
     auto const& d = p.second->proxyProviderDescriptions();
     descriptions.insert(d.begin(),d.end());
   }
   if(dataProviders_.get()) {
     for(auto const& p: *dataProviders_) {
       descriptions.insert(p->description());
     }
   }
                       
   return descriptions;
}

void EventSetupProvider::replaceExisting

(

std::shared_ptr< DataProxyProvider >

dataProxyProvider

)

Definition at line 122 of file EventSetupProvider.cc.

References crabWrapper::key.

Referenced by eventSetup(), and edm::eventsetup::ModuleMakerTraits::replaceExisting().

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

void EventSetupProvider::resetRecordPlusDependentRecords

(

EventSetupRecordKey const &

)

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

Definition at line 422 of file EventSetupProvider.cc.

References edmIntegrityCheck::d, edm::eventsetup::findDependents(), and tier0::unique().

Referenced by eventSetup(), and edm::EDLooperBase::prepareForNextLoop().

{
  Providers::iterator itFind = providers_.find(iKey);
  if(itFind == providers_.end()) {
    return;
  }

  
  std::vector<std::shared_ptr<EventSetupRecordProvider> > dependents;
  findDependents(iKey, providers_.begin(), providers_.end(), dependents);

  dependents.erase(std::unique(dependents.begin(),dependents.end()), dependents.end());
  
  itFind->second->resetProxies();
  for(auto& d: dependents) {
    d->resetProxies();
  }
}

void EventSetupProvider::resetRecordToProxyPointers

(

)

Definition at line 712 of file EventSetupProvider.cc.

Referenced by eventSetup().

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

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

inline

Definition at line 104 of file EventSetupProvider.h.

References logInfoWhenSharing(), and subProcessIndex_.

Referenced by checkESProducerSharing().

{ return subProcessIndex_; }

Member Data Documentation

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

private

Definition at line 138 of file EventSetupProvider.h.

EventSetup edm::eventsetup::EventSetupProvider::eventSetup_

private

Definition at line 127 of file EventSetupProvider.h.

Referenced by eventSetup().

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

private

Definition at line 137 of file EventSetupProvider.h.

std::unique_ptr<EventSetupKnownRecordsSupplier> edm::eventsetup::EventSetupProvider::knownRecordsSupplier_

private

Definition at line 130 of file EventSetupProvider.h.

bool edm::eventsetup::EventSetupProvider::mustFinishConfiguration_

private

Definition at line 131 of file EventSetupProvider.h.

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

private

Definition at line 136 of file EventSetupProvider.h.

Providers edm::eventsetup::EventSetupProvider::providers_

private

Definition at line 129 of file EventSetupProvider.h.

Referenced by checkESProducerSharing().

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

private

Definition at line 141 of file EventSetupProvider.h.

Referenced by checkESProducerSharing().

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

private

Definition at line 143 of file EventSetupProvider.h.

Referenced by doRecordsMatch().

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

private

Definition at line 140 of file EventSetupProvider.h.

Referenced by doRecordsMatch().

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

private

Definition at line 142 of file EventSetupProvider.h.

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

private

Definition at line 139 of file EventSetupProvider.h.

Referenced by doRecordsMatch().

unsigned edm::eventsetup::EventSetupProvider::subProcessIndex_

private

Definition at line 132 of file EventSetupProvider.h.

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