edm::eventsetup::EventSetupsController Class Reference

#include <EventSetupsController.h>

Public Member Functions
void	clearComponents ()
bool	doWeNeedToWaitForIOVsToFinish (IOVSyncValue const &) const
void	endIOVsAsync (edm::WaitingTaskHolder iEndTask)
std::multimap< ParameterSetID, ESProducerInfo > const &	esproducers () const
std::multimap< ParameterSetID, ESSourceInfo > const &	essources () const
void	eventSetupForInstanceAsync (IOVSyncValue const &, WaitingTaskHolder const &taskToStartAfterIOVInit, WaitingTaskList &endIOVWaitingTasks, std::vector< std::shared_ptr< const EventSetupImpl >> &)
	EventSetupsController ()
	EventSetupsController (ModuleTypeResolverMaker const *resolverMaker)
	EventSetupsController (EventSetupsController const &)=delete
void	finishConfiguration ()
void	forceCacheClear ()
std::shared_ptr< DataProxyProvider >	getESProducerAndRegisterProcess (ParameterSet const &pset, unsigned subProcessIndex)
ParameterSet &	getESProducerPSet (ParameterSetID const &psetID, unsigned subProcessIndex)
std::shared_ptr< EventSetupRecordIntervalFinder >	getESSourceAndRegisterProcess (ParameterSet const &pset, unsigned subProcessIndex)
bool	hasNonconcurrentFinder () const
unsigned	indexOfNextProcess () const
bool	isFirstMatch (ParameterSetID const &psetID, unsigned subProcessIndex, unsigned precedingProcessIndex) const
bool	isLastMatch (ParameterSetID const &psetID, unsigned subProcessIndex, unsigned precedingProcessIndex) const
bool	isMatchingESProducer (ParameterSetID const &psetID, unsigned subProcessIndex, unsigned precedingProcessIndex) const
bool	isMatchingESSource (ParameterSetID const &psetID, unsigned subProcessIndex, unsigned precedingProcessIndex) const
void	lookForMatches (ParameterSetID const &psetID, unsigned subProcessIndex, unsigned precedingProcessIndex, bool &firstProcessWithThisPSet, bool &precedingHasMatchingPSet) const
std::shared_ptr< EventSetupProvider >	makeProvider (ParameterSet &, ActivityRegistry *, ParameterSet const *eventSetupPset=nullptr, unsigned int maxConcurrentIOVs=0, bool dumpOptions=false)
bool	mustFinishConfiguration () const
EventSetupsController const &	operator= (EventSetupsController const &)=delete
std::vector< propagate_const< std::shared_ptr< EventSetupProvider > > > const &	providers () const
void	putESProducer (ParameterSet &pset, std::shared_ptr< DataProxyProvider > const &component, unsigned subProcessIndex)
void	putESSource (ParameterSet const &pset, std::shared_ptr< EventSetupRecordIntervalFinder > const &component, unsigned subProcessIndex)
void	runOrQueueEventSetupForInstanceAsync (IOVSyncValue const &, WaitingTaskHolder &taskToStartAfterIOVInit, WaitingTaskList &endIOVWaitingTasks, std::vector< std::shared_ptr< const EventSetupImpl >> &, edm::SerialTaskQueue &queueWhichWaitsForIOVsToFinish, ActivityRegistry *, ServiceToken const &, bool iForceCacheClear=false)

Private Member Functions
void	checkESProducerSharing ()
void	initializeEventSetupRecordIOVQueues ()

Private Attributes
std::multimap< ParameterSetID, ESProducerInfo >	esproducers_
std::multimap< ParameterSetID, ESSourceInfo >	essources_
std::vector< propagate_const< std::unique_ptr< EventSetupRecordIOVQueue > > >	eventSetupRecordIOVQueues_
bool	hasNonconcurrentFinder_ = false
bool	mustFinishConfiguration_ = true
NumberOfConcurrentIOVs	numberOfConcurrentIOVs_
std::vector< propagate_const< std::shared_ptr< EventSetupProvider > > >	providers_
ModuleTypeResolverMaker const *	typeResolverMaker_ = nullptr

Detailed Description

Description: Manages a group of EventSetups which can share components

Usage: <usage>

Definition at line 82 of file EventSetupsController.h.

Constructor & Destructor Documentation

EventSetupsController() [1/3]

edm::eventsetup::EventSetupsController::EventSetupsController

(

)

Definition at line 41 of file EventSetupsController.cc.

{}

EventSetupsController() [2/3]

edm::eventsetup::EventSetupsController::EventSetupsController ( ModuleTypeResolverMaker const *  resolverMaker )

explicit

Definition at line 42 of file EventSetupsController.cc.

        : typeResolverMaker_(resolverMaker) {}

EventSetupsController() [3/3]

edm::eventsetup::EventSetupsController::EventSetupsController ( EventSetupsController const &  )

delete

Member Function Documentation

checkESProducerSharing()

void edm::eventsetup::EventSetupsController::checkESProducerSharing ( )

private

Definition at line 411 of file EventSetupsController.cc.

References providers_, and typeResolverMaker_.

Referenced by finishConfiguration().

                                                       {
      // Loop over SubProcesses, skip the top level process.
      auto esProvider = providers_.begin();
      auto const esProviderEnd = providers_.end();
      if (esProvider != esProviderEnd)
        ++esProvider;
      for (; esProvider != esProviderEnd; ++esProvider) {
        // An element is added to this set for each ESProducer
        // when we have determined which preceding process
        // this process can share that ESProducer with or
        // we have determined that it cannot be shared with
        // any preceding process.
        // Note the earliest possible preceding process
        // will be the one selected if there is more than one.
        std::set<ParameterSetIDHolder> sharingCheckDone;

        // This will hold an entry for DataProxy's that are
        // referenced by an EventSetupRecord in this SubProcess.
        // But only for DataProxy's that are associated with
        // an ESProducer (not the ones associated with ESSource's
        // or EDLooper's)
        std::map<EventSetupRecordKey, std::vector<ComponentDescription const*>> referencedESProducers;

        // For each EventSetupProvider from a SubProcess, loop over the
        // EventSetupProviders from the preceding processes (the first
        // preceding process will be the top level process and the others
        // SubProcess's)
        for (auto precedingESProvider = providers_.begin(); precedingESProvider != esProvider; ++precedingESProvider) {
          (*esProvider)
              ->checkESProducerSharing(
                  typeResolverMaker_, **precedingESProvider, sharingCheckDone, referencedESProducers, *this);
        }

        (*esProvider)->resetRecordToProxyPointers();
      }
      for (auto& eventSetupProvider : providers_) {
        eventSetupProvider->clearInitializationData();
      }
    }

clearComponents()

void edm::eventsetup::EventSetupsController::clearComponents

(

)

Definition at line 256 of file EventSetupsController.cc.

References esproducers_, and essources_.

Referenced by finishConfiguration().

                                                {
      esproducers_.clear();
      essources_.clear();
    }

doWeNeedToWaitForIOVsToFinish()

bool edm::eventsetup::EventSetupsController::doWeNeedToWaitForIOVsToFinish

(

IOVSyncValue const &

syncValue

)

const

Definition at line 187 of file EventSetupsController.cc.

References hasNonconcurrentFinder(), and providers_.

Referenced by runOrQueueEventSetupForInstanceAsync().

                                                                                                 {
      if (hasNonconcurrentFinder()) {
        for (auto& eventSetupProvider : providers_) {
          if (eventSetupProvider->doWeNeedToWaitForIOVsToFinish(syncValue)) {
            return true;
          }
        }
      }
      return false;
    }

endIOVsAsync()

void edm::eventsetup::EventSetupsController::endIOVsAsync

(

edm::WaitingTaskHolder

iEndTask

)

Definition at line 45 of file EventSetupsController.cc.

References eventSetupRecordIOVQueues_.

Referenced by edm::eventsetup::SynchronousEventSetupsController::~SynchronousEventSetupsController().

                                                                          {
      for (auto& eventSetupRecordIOVQueue : eventSetupRecordIOVQueues_) {
        eventSetupRecordIOVQueue->endIOVAsync(iEndTask);
      }
    }

esproducers()

std::multimap<ParameterSetID, ESProducerInfo> const& edm::eventsetup::EventSetupsController::esproducers ( ) const

inline

Definition at line 172 of file EventSetupsController.h.

References esproducers_.

{ return esproducers_; }

essources()

std::multimap<ParameterSetID, ESSourceInfo> const& edm::eventsetup::EventSetupsController::essources ( ) const

inline

Definition at line 174 of file EventSetupsController.h.

References essources_.

{ return essources_; }

eventSetupForInstanceAsync()

void edm::eventsetup::EventSetupsController::eventSetupForInstanceAsync	(	IOVSyncValue const &	syncValue,
		WaitingTaskHolder const &	taskToStartAfterIOVInit,
		WaitingTaskList &	endIOVWaitingTasks,
		std::vector< std::shared_ptr< const EventSetupImpl >> &	eventSetupImpls
	)

Definition at line 148 of file EventSetupsController.cc.

References eventSetupRecordIOVQueues_, finishConfiguration(), and providers_.

Referenced by runOrQueueEventSetupForInstanceAsync(), and edm::eventsetup::synchronousEventSetupForInstance().

                                                                         {
      finishConfiguration();

      bool newEventSetupImpl = false;
      eventSetupImpls.clear();
      eventSetupImpls.reserve(providers_.size());

      // Note that unless there are one or more SubProcesses providers_ will only
      // contain one element.

      for (auto& eventSetupProvider : providers_) {
        eventSetupProvider->setAllValidityIntervals(syncValue);
      }

      for (auto& eventSetupRecordIOVQueue : eventSetupRecordIOVQueues_) {
        // For a particular record, if the top level process or any SubProcess requires
        // starting a new IOV, then we must start a new IOV for all of them. And we
        // need to know whether this is needed at this point in time. This is
        // recorded in the EventSetupRecordProviders.
        eventSetupRecordIOVQueue->setNewIntervalForAnySubProcess();
      }

      for (auto& eventSetupProvider : providers_) {
        // Decides whether we can reuse the existing EventSetupImpl and if we can
        // returns it. If a new one is needed it will create it, although the pointers
        // to the EventSetupRecordImpl's will not be set yet in the returned EventSetupImpl
        // object.
        eventSetupImpls.push_back(eventSetupProvider->eventSetupForInstance(syncValue, newEventSetupImpl));
      }

      for (auto& eventSetupRecordIOVQueue : eventSetupRecordIOVQueues_) {
        eventSetupRecordIOVQueue->checkForNewIOVs(taskToStartAfterIOVInit, endIOVWaitingTasks, newEventSetupImpl);
      }
    }

finishConfiguration()

void edm::eventsetup::EventSetupsController::finishConfiguration

(

)

Definition at line 73 of file EventSetupsController.cc.

References checkESProducerSharing(), edm::eventsetup::NumberOfConcurrentIOVs::clear(), clearComponents(), edm::eventsetup::NumberOfConcurrentIOVs::fillRecordsNotAllowingConcurrentIOVs(), hasNonconcurrentFinder_, initializeEventSetupRecordIOVQueues(), mustFinishConfiguration_, numberOfConcurrentIOVs_, and providers_.

Referenced by eventSetupForInstanceAsync().

                                                    {
      if (mustFinishConfiguration_) {
        for (auto& eventSetupProvider : providers_) {
          numberOfConcurrentIOVs_.fillRecordsNotAllowingConcurrentIOVs(*eventSetupProvider);
        }

        for (auto& eventSetupProvider : providers_) {
          eventSetupProvider->finishConfiguration(numberOfConcurrentIOVs_, hasNonconcurrentFinder_);
        }

        // When the ESSources and ESProducers were constructed a first pass was
        // done which attempts to get component sharing between SubProcesses
        // correct, but in this pass only the configuration of the components
        // being shared are compared. This is not good enough for ESProducers.
        // In the following function, all the other components that contribute
        // to the same record and also the records that record depends on are
        // also checked. The component sharing is appropriately fixed as necessary.
        checkESProducerSharing();
        clearComponents();

        initializeEventSetupRecordIOVQueues();
        numberOfConcurrentIOVs_.clear();
        mustFinishConfiguration_ = false;
      }
    }

forceCacheClear()

void edm::eventsetup::EventSetupsController::forceCacheClear

(

)

Definition at line 198 of file EventSetupsController.cc.

References providers_.

Referenced by runOrQueueEventSetupForInstanceAsync().

                                                {
      for (auto& eventSetupProvider : providers_) {
        eventSetupProvider->forceCacheClear();
      }
    }

getESProducerAndRegisterProcess()

std::shared_ptr< DataProxyProvider > edm::eventsetup::EventSetupsController::getESProducerAndRegisterProcess	(	ParameterSet const &	pset,
		unsigned	subProcessIndex
	)

Definition at line 204 of file EventSetupsController.cc.

References bookConverter::elements, esproducers_, edm::isTransientEqual(), and muonDTDigis_cfi::pset.

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

                                                            {
      // Try to find a DataProxyProvider with a matching ParameterSet
      auto elements = esproducers_.equal_range(pset.id());
      for (auto it = elements.first; it != elements.second; ++it) {
        // Untracked parameters must also match, do complete comparison if IDs match
        if (isTransientEqual(pset, *it->second.pset())) {
          // Register processes with an exact match
          it->second.subProcessIndexes().push_back(subProcessIndex);
          // Return the DataProxyProvider
          return it->second.provider();
        }
      }
      // Could not find it
      return std::shared_ptr<DataProxyProvider>();
    }

getESProducerPSet()

ParameterSet & edm::eventsetup::EventSetupsController::getESProducerPSet	(	ParameterSetID const &	psetID,
		unsigned	subProcessIndex
	)

Definition at line 395 of file EventSetupsController.cc.

References bookConverter::elements, esproducers_, Exception, spr::find(), and edm::errors::LogicError.

Referenced by edm::eventsetup::EventSetupProvider::checkESProducerSharing().

                                                                                                                 {
      auto elements = esproducers_.equal_range(psetID);
      for (auto it = elements.first; it != elements.second; ++it) {
        std::vector<unsigned> const& subProcessIndexes = it->second.subProcessIndexes();

        auto iFound = std::find(subProcessIndexes.begin(), subProcessIndexes.end(), subProcessIndex);
        if (iFound == subProcessIndexes.end()) {
          continue;
        }
        return *it->second.pset();
      }
      throw edm::Exception(edm::errors::LogicError) << "EventSetupsController::getESProducerPSet\n"
                                                    << "Subprocess index not found. This should never happen\n"
                                                    << "Please report this to a Framework Developer\n";
    }

getESSourceAndRegisterProcess()

std::shared_ptr< EventSetupRecordIntervalFinder > edm::eventsetup::EventSetupsController::getESSourceAndRegisterProcess	(	ParameterSet const &	pset,
		unsigned	subProcessIndex
	)

Definition at line 230 of file EventSetupsController.cc.

References bookConverter::elements, essources_, edm::isTransientEqual(), and muonDTDigis_cfi::pset.

Referenced by edm::eventsetup::SourceMakerTraits::getComponentAndRegisterProcess().

                                                            {
      // Try to find a EventSetupRecordIntervalFinder with a matching ParameterSet
      auto elements = essources_.equal_range(pset.id());
      for (auto it = elements.first; it != elements.second; ++it) {
        // Untracked parameters must also match, do complete comparison if IDs match
        if (isTransientEqual(pset, *it->second.pset())) {
          // Register processes with an exact match
          it->second.subProcessIndexes().push_back(subProcessIndex);
          // Return the EventSetupRecordIntervalFinder
          return it->second.finder();
        }
      }
      // Could not find it
      return std::shared_ptr<EventSetupRecordIntervalFinder>();
    }

hasNonconcurrentFinder()

bool edm::eventsetup::EventSetupsController::hasNonconcurrentFinder ( ) const

inline

Definition at line 176 of file EventSetupsController.h.

References hasNonconcurrentFinder_.

Referenced by doWeNeedToWaitForIOVsToFinish().

{ return hasNonconcurrentFinder_; }

indexOfNextProcess()

unsigned edm::eventsetup::EventSetupsController::indexOfNextProcess ( ) const

inline

Definition at line 148 of file EventSetupsController.h.

References providers_.

Referenced by edm::eventsetup::ModuleMakerTraits::getComponentAndRegisterProcess(), edm::eventsetup::SourceMakerTraits::getComponentAndRegisterProcess(), edm::eventsetup::ModuleMakerTraits::putComponent(), and edm::eventsetup::SourceMakerTraits::putComponent().

{ return providers_.size(); }

initializeEventSetupRecordIOVQueues()

void edm::eventsetup::EventSetupsController::initializeEventSetupRecordIOVQueues ( )

private

Definition at line 451 of file EventSetupsController.cc.

References edm::eventsetup::EventSetupRecordIOVQueue::addRecProvider(), eventSetupRecordIOVQueues_, crabWrapper::key, relativeConstraints::keys, edm::eventsetup::NumberOfConcurrentIOVs::numberOfConcurrentIOVs(), numberOfConcurrentIOVs_, and providers_.

Referenced by finishConfiguration().

                                                                    {
      std::set<EventSetupRecordKey> keys;
      for (auto const& provider : providers_) {
        provider->fillKeys(keys);
      }

      for (auto const& key : keys) {
        eventSetupRecordIOVQueues_.push_back(
            std::make_unique<EventSetupRecordIOVQueue>(numberOfConcurrentIOVs_.numberOfConcurrentIOVs(key)));
        EventSetupRecordIOVQueue& iovQueue = *eventSetupRecordIOVQueues_.back();
        for (auto& provider : providers_) {
          EventSetupRecordProvider* recProvider = provider->tryToGetRecordProvider(key);
          if (recProvider) {
            iovQueue.addRecProvider(recProvider);
          }
        }
      }
    }

isFirstMatch()

bool edm::eventsetup::EventSetupsController::isFirstMatch	(	ParameterSetID const &	psetID,
		unsigned	subProcessIndex,
		unsigned	precedingProcessIndex
	)		const

Definition at line 295 of file EventSetupsController.cc.

References bookConverter::elements, esproducers_, Exception, spr::find(), and edm::errors::LogicError.

Referenced by edm::eventsetup::EventSetupProvider::checkESProducerSharing().

                                                                                   {
      auto elements = esproducers_.equal_range(psetID);
      for (auto it = elements.first; it != elements.second; ++it) {
        std::vector<unsigned> const& subProcessIndexes = it->second.subProcessIndexes();

        auto iFound = std::find(subProcessIndexes.begin(), subProcessIndexes.end(), subProcessIndex);
        if (iFound == subProcessIndexes.end()) {
          continue;
        }

        auto iFoundPreceding = std::find(subProcessIndexes.begin(), iFound, precedingProcessIndex);
        if (iFoundPreceding == iFound) {
          break;
        } else {
          return iFoundPreceding == subProcessIndexes.begin();
        }
      }
      throw edm::Exception(edm::errors::LogicError) << "EventSetupsController::isFirstMatch\n"
                                                    << "Subprocess index not found. This should never happen\n"
                                                    << "Please report this to a Framework Developer\n";
      return false;
    }

isLastMatch()

bool edm::eventsetup::EventSetupsController::isLastMatch	(	ParameterSetID const &	psetID,
		unsigned	subProcessIndex,
		unsigned	precedingProcessIndex
	)		const

Definition at line 320 of file EventSetupsController.cc.

References bookConverter::elements, esproducers_, Exception, spr::find(), and edm::errors::LogicError.

Referenced by edm::eventsetup::EventSetupProvider::checkESProducerSharing().

                                                                                  {
      auto elements = esproducers_.equal_range(psetID);
      for (auto it = elements.first; it != elements.second; ++it) {
        std::vector<unsigned> const& subProcessIndexes = it->second.subProcessIndexes();

        auto iFound = std::find(subProcessIndexes.begin(), subProcessIndexes.end(), subProcessIndex);
        if (iFound == subProcessIndexes.end()) {
          continue;
        }

        auto iFoundPreceding = std::find(subProcessIndexes.begin(), iFound, precedingProcessIndex);
        if (iFoundPreceding == iFound) {
          break;
        } else {
          return (++iFoundPreceding) == iFound;
        }
      }
      throw edm::Exception(edm::errors::LogicError) << "EventSetupsController::isLastMatch\n"
                                                    << "Subprocess index not found. This should never happen\n"
                                                    << "Please report this to a Framework Developer\n";
      return false;
    }

isMatchingESProducer()

bool edm::eventsetup::EventSetupsController::isMatchingESProducer	(	ParameterSetID const &	psetID,
		unsigned	subProcessIndex,
		unsigned	precedingProcessIndex
	)		const

Definition at line 370 of file EventSetupsController.cc.

References bookConverter::elements, esproducers_, Exception, spr::find(), and edm::errors::LogicError.

Referenced by edm::eventsetup::EventSetupProvider::doRecordsMatch().

                                                                                           {
      auto elements = esproducers_.equal_range(psetID);
      for (auto it = elements.first; it != elements.second; ++it) {
        std::vector<unsigned> const& subProcessIndexes = it->second.subProcessIndexes();

        auto iFound = std::find(subProcessIndexes.begin(), subProcessIndexes.end(), subProcessIndex);
        if (iFound == subProcessIndexes.end()) {
          continue;
        }

        auto iFoundPreceding = std::find(subProcessIndexes.begin(), iFound, precedingProcessIndex);
        if (iFoundPreceding == iFound) {
          return false;
        } else {
          return true;
        }
      }
      throw edm::Exception(edm::errors::LogicError) << "EventSetupsController::lookForMatchingESSource\n"
                                                    << "Subprocess index not found. This should never happen\n"
                                                    << "Please report this to a Framework Developer\n";
      return false;
    }

isMatchingESSource()

bool edm::eventsetup::EventSetupsController::isMatchingESSource	(	ParameterSetID const &	psetID,
		unsigned	subProcessIndex,
		unsigned	precedingProcessIndex
	)		const

Definition at line 345 of file EventSetupsController.cc.

References bookConverter::elements, essources_, Exception, spr::find(), and edm::errors::LogicError.

Referenced by edm::eventsetup::EventSetupProvider::doRecordsMatch().

                                                                                         {
      auto elements = essources_.equal_range(psetID);
      for (auto it = elements.first; it != elements.second; ++it) {
        std::vector<unsigned> const& subProcessIndexes = it->second.subProcessIndexes();

        auto iFound = std::find(subProcessIndexes.begin(), subProcessIndexes.end(), subProcessIndex);
        if (iFound == subProcessIndexes.end()) {
          continue;
        }

        auto iFoundPreceding = std::find(subProcessIndexes.begin(), iFound, precedingProcessIndex);
        if (iFoundPreceding == iFound) {
          return false;
        } else {
          return true;
        }
      }
      throw edm::Exception(edm::errors::LogicError) << "EventSetupsController::lookForMatchingESSource\n"
                                                    << "Subprocess index not found. This should never happen\n"
                                                    << "Please report this to a Framework Developer\n";
      return false;
    }

lookForMatches()

void edm::eventsetup::EventSetupsController::lookForMatches	(	ParameterSetID const &	psetID,
		unsigned	subProcessIndex,
		unsigned	precedingProcessIndex,
		bool &	firstProcessWithThisPSet,
		bool &	precedingHasMatchingPSet
	)		const

Definition at line 261 of file EventSetupsController.cc.

References bookConverter::elements, esproducers_, Exception, spr::find(), and edm::errors::LogicError.

Referenced by edm::eventsetup::EventSetupProvider::checkESProducerSharing().

                                                                                     {
      auto elements = esproducers_.equal_range(psetID);
      for (auto it = elements.first; it != elements.second; ++it) {
        std::vector<unsigned> const& subProcessIndexes = it->second.subProcessIndexes();

        auto iFound = std::find(subProcessIndexes.begin(), subProcessIndexes.end(), subProcessIndex);
        if (iFound == subProcessIndexes.end()) {
          continue;
        }

        if (iFound == subProcessIndexes.begin()) {
          firstProcessWithThisPSet = true;
          precedingHasMatchingPSet = false;
        } else {
          auto iFoundPreceding = std::find(subProcessIndexes.begin(), iFound, precedingProcessIndex);
          if (iFoundPreceding == iFound) {
            firstProcessWithThisPSet = false;
            precedingHasMatchingPSet = false;
          } else {
            firstProcessWithThisPSet = false;
            precedingHasMatchingPSet = true;
          }
        }
        return;
      }
      throw edm::Exception(edm::errors::LogicError) << "EventSetupsController::lookForMatches\n"
                                                    << "Subprocess index not found. This should never happen\n"
                                                    << "Please report this to a Framework Developer\n";
    }

makeProvider()

std::shared_ptr< EventSetupProvider > edm::eventsetup::EventSetupsController::makeProvider	(	ParameterSet &	iPSet,
		ActivityRegistry *	activityRegistry,
		ParameterSet const *	eventSetupPset = nullptr,
		unsigned int	maxConcurrentIOVs = 0,
		bool	dumpOptions = false
	)

Definition at line 51 of file EventSetupsController.cc.

References testHGCalDigi_cfg::dumpOptions, edm::eventsetup::fillEventSetupProvider(), edm::eventsetup::makeEventSetupProvider(), numberOfConcurrentIOVs_, providers_, edm::eventsetup::NumberOfConcurrentIOVs::readConfigurationParameters(), and typeResolverMaker_.

Referenced by edm::eventsetup::SynchronousEventSetupsController::makeProvider(), and edm::SubProcess::SubProcess().

                                                                                              {
      // Makes an EventSetupProvider
      // Also parses the prefer information from ParameterSets and puts
      // it in a map that is stored in the EventSetupProvider
      std::shared_ptr<EventSetupProvider> returnValue(
          makeEventSetupProvider(iPSet, providers_.size(), activityRegistry));

      // Construct the ESProducers and ESSources
      // shared_ptrs to them are temporarily stored in this
      // EventSetupsController and in the EventSetupProvider
      fillEventSetupProvider(typeResolverMaker_, *this, *returnValue, iPSet);

      numberOfConcurrentIOVs_.readConfigurationParameters(eventSetupPset, maxConcurrentIOVs, dumpOptions);

      providers_.push_back(returnValue);
      return returnValue;
    }

mustFinishConfiguration()

bool edm::eventsetup::EventSetupsController::mustFinishConfiguration ( ) const

inline

Definition at line 177 of file EventSetupsController.h.

References mustFinishConfiguration_.

{ return mustFinishConfiguration_; }

operator=()

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

delete

providers()

std::vector<propagate_const<std::shared_ptr<EventSetupProvider> > > const& edm::eventsetup::EventSetupsController::providers ( ) const

inline

Definition at line 170 of file EventSetupsController.h.

References providers_.

{ return providers_; }

putESProducer()

void edm::eventsetup::EventSetupsController::putESProducer	(	ParameterSet &	pset,
		std::shared_ptr< DataProxyProvider > const &	component,
		unsigned	subProcessIndex
	)

Definition at line 221 of file EventSetupsController.cc.

References esproducers_, and muonDTDigis_cfi::pset.

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

                                                                        {
      auto newElement =
          esproducers_.insert(std::pair<ParameterSetID, ESProducerInfo>(pset.id(), ESProducerInfo(&pset, component)));
      // Register processes with an exact match
      newElement->second.subProcessIndexes().push_back(subProcessIndex);
    }

putESSource()

void edm::eventsetup::EventSetupsController::putESSource	(	ParameterSet const &	pset,
		std::shared_ptr< EventSetupRecordIntervalFinder > const &	component,
		unsigned	subProcessIndex
	)

Definition at line 247 of file EventSetupsController.cc.

References essources_, and muonDTDigis_cfi::pset.

Referenced by edm::eventsetup::SourceMakerTraits::putComponent().

                                                                      {
      auto newElement =
          essources_.insert(std::pair<ParameterSetID, ESSourceInfo>(pset.id(), ESSourceInfo(&pset, component)));
      // Register processes with an exact match
      newElement->second.subProcessIndexes().push_back(subProcessIndex);
    }

runOrQueueEventSetupForInstanceAsync()

void edm::eventsetup::EventSetupsController::runOrQueueEventSetupForInstanceAsync	(	IOVSyncValue const &	iSync,
		WaitingTaskHolder &	taskToStartAfterIOVInit,
		WaitingTaskList &	endIOVWaitingTasks,
		std::vector< std::shared_ptr< const EventSetupImpl >> &	eventSetupImpls,
		edm::SerialTaskQueue &	queueWhichWaitsForIOVsToFinish,
		ActivityRegistry *	actReg,
		ServiceToken const &	iToken,
		bool	iForceCacheClear = false
	)

Definition at line 99 of file EventSetupsController.cc.

References CMS_SA_ALLOW, edm::SendSourceTerminationSignalIfException::completedSuccessfully(), doWeNeedToWaitForIOVsToFinish(), eventSetupForInstanceAsync(), forceCacheClear(), edm::WaitingTaskHolder::group(), watchdog::group, edm::ServiceWeakToken::lock(), and TrackValidation_cff::task.

                               {
      auto asyncEventSetup =
          [this, &endIOVWaitingTasks, &eventSetupImpls, &queueWhichWaitsForIOVsToFinish, actReg, iForceCacheClear](
              IOVSyncValue const& iSync, WaitingTaskHolder& task) {
            queueWhichWaitsForIOVsToFinish.pause();
            CMS_SA_ALLOW try {
              if (iForceCacheClear) {
                forceCacheClear();
              }
              SendSourceTerminationSignalIfException sentry(actReg);
              {
                //all EventSetupRecordIntervalFinders are sequentially set to the
                // new SyncValue in the call. The async part is just waiting for
                // the Records to be available which is done after the SyncValue setup.
                actReg->preESSyncIOVSignal_.emit(iSync);
                auto postSignal = [&iSync](ActivityRegistry* actReg) { actReg->postESSyncIOVSignal_.emit(iSync); };
                std::unique_ptr<ActivityRegistry, decltype(postSignal)> guard(actReg, postSignal);
                eventSetupForInstanceAsync(iSync, task, endIOVWaitingTasks, eventSetupImpls);
              }
              sentry.completedSuccessfully();
            } catch (...) {
              task.doneWaiting(std::current_exception());
            }
          };
      if (doWeNeedToWaitForIOVsToFinish(iSync) || iForceCacheClear) {
        // We get inside this block if there is an EventSetup
        // module not able to handle concurrent IOVs (usually an ESSource)
        // and the new sync value is outside the current IOV of that module.
        // Also at beginRun when forcing caches to clear.
        auto group = taskToStartAfterIOVInit.group();
        ServiceWeakToken weakToken = iToken;
        queueWhichWaitsForIOVsToFinish.push(*group,
                                            [iSync, taskToStartAfterIOVInit, asyncEventSetup, weakToken]() mutable {
                                              ServiceRegistry::Operate operate(weakToken.lock());
                                              asyncEventSetup(iSync, taskToStartAfterIOVInit);
                                            });
      } else {
        asyncEventSetup(iSync, taskToStartAfterIOVInit);
      }
    }

Member Data Documentation

esproducers_

std::multimap<ParameterSetID, ESProducerInfo> edm::eventsetup::EventSetupsController::esproducers_

private

Definition at line 201 of file EventSetupsController.h.

Referenced by clearComponents(), esproducers(), getESProducerAndRegisterProcess(), getESProducerPSet(), isFirstMatch(), isLastMatch(), isMatchingESProducer(), lookForMatches(), and putESProducer().

essources_

std::multimap<ParameterSetID, ESSourceInfo> edm::eventsetup::EventSetupsController::essources_

private

Definition at line 202 of file EventSetupsController.h.

Referenced by clearComponents(), essources(), getESSourceAndRegisterProcess(), isMatchingESSource(), and putESSource().

eventSetupRecordIOVQueues_

std::vector<propagate_const<std::unique_ptr<EventSetupRecordIOVQueue> > > edm::eventsetup::EventSetupsController::eventSetupRecordIOVQueues_

private

Definition at line 189 of file EventSetupsController.h.

Referenced by endIOVsAsync(), eventSetupForInstanceAsync(), and initializeEventSetupRecordIOVQueues().

hasNonconcurrentFinder_

bool edm::eventsetup::EventSetupsController::hasNonconcurrentFinder_ = false

private

Definition at line 206 of file EventSetupsController.h.

Referenced by finishConfiguration(), and hasNonconcurrentFinder().

mustFinishConfiguration_

bool edm::eventsetup::EventSetupsController::mustFinishConfiguration_ = true

private

Definition at line 207 of file EventSetupsController.h.

Referenced by finishConfiguration(), and mustFinishConfiguration().

numberOfConcurrentIOVs_

NumberOfConcurrentIOVs edm::eventsetup::EventSetupsController::numberOfConcurrentIOVs_

private

Definition at line 185 of file EventSetupsController.h.

Referenced by finishConfiguration(), initializeEventSetupRecordIOVQueues(), and makeProvider().

providers_

std::vector<propagate_const<std::shared_ptr<EventSetupProvider> > > edm::eventsetup::EventSetupsController::providers_

private

Definition at line 184 of file EventSetupsController.h.

Referenced by checkESProducerSharing(), doWeNeedToWaitForIOVsToFinish(), eventSetupForInstanceAsync(), finishConfiguration(), forceCacheClear(), indexOfNextProcess(), initializeEventSetupRecordIOVQueues(), makeProvider(), and providers().

typeResolverMaker_

ModuleTypeResolverMaker const* edm::eventsetup::EventSetupsController::typeResolverMaker_ = nullptr

private

Definition at line 204 of file EventSetupsController.h.

Referenced by checkESProducerSharing(), and makeProvider().