#include <NumberOfConcurrentIOVs.h>

Public Member Functions
void	clear ()

void	fillRecordsNotAllowingConcurrentIOVs (EventSetupProvider const &)

	NumberOfConcurrentIOVs ()

unsigned int	numberOfConcurrentIOVs (EventSetupRecordKey const &, bool printInfoMsg=false) const

void	readConfigurationParameters (ParameterSet const *eventSetupPset, unsigned int maxConcurrentIOVs, bool dumpOptions)

Private Attributes
std::vector< std::pair< EventSetupRecordKey, unsigned int > >	forceNumberOfConcurrentIOVs_

unsigned int	maxConcurrentIOVs_ = 1

unsigned int	numberConcurrentIOVs_

std::set< EventSetupRecordKey >	recordsNotAllowingConcurrentIOVs_

Detailed Description

Description: Calculates and holds the number of concurrent intervals of validity allowed for each record in the EventSetup.

Usage: Used internally by the Framework

Definition at line 35 of file NumberOfConcurrentIOVs.h.

Constructor & Destructor Documentation

◆ NumberOfConcurrentIOVs()

edm::eventsetup::NumberOfConcurrentIOVs::NumberOfConcurrentIOVs ( )

Definition at line 17 of file NumberOfConcurrentIOVs.cc.

17 : numberConcurrentIOVs_(1) {}

Member Function Documentation

◆ clear()

void edm::eventsetup::NumberOfConcurrentIOVs::clear ( void )

Definition at line 77 of file NumberOfConcurrentIOVs.cc.

                                        {
       // Mark this as invalid
       numberConcurrentIOVs_ = 0;
  
       // Free up memory
       recordsNotAllowingConcurrentIOVs_.clear();
       std::vector<std::pair<EventSetupRecordKey, unsigned int>>().swap(forceNumberOfConcurrentIOVs_);
     }

References forceNumberOfConcurrentIOVs_, numberConcurrentIOVs_, recordsNotAllowingConcurrentIOVs_, and edm::eventsetup::swap().

Referenced by edm::eventsetup::EventSetupsController::finishConfiguration().

◆ fillRecordsNotAllowingConcurrentIOVs()

void edm::eventsetup::NumberOfConcurrentIOVs::fillRecordsNotAllowingConcurrentIOVs ( EventSetupProvider const & eventSetupProvider )

Definition at line 45 of file NumberOfConcurrentIOVs.cc.

                                                                                                                   {
       eventSetupProvider.fillRecordsNotAllowingConcurrentIOVs(recordsNotAllowingConcurrentIOVs_);
     }

References edm::eventsetup::EventSetupProvider::fillRecordsNotAllowingConcurrentIOVs(), and recordsNotAllowingConcurrentIOVs_.

Referenced by edm::eventsetup::EventSetupsController::finishConfiguration().

◆ numberOfConcurrentIOVs()

unsigned int edm::eventsetup::NumberOfConcurrentIOVs::numberOfConcurrentIOVs	(	EventSetupRecordKey const &	eventSetupKey,
		bool	printInfoMsg = `false`
	)		const

Definition at line 49 of file NumberOfConcurrentIOVs.cc.

                                                                                          {
       assert(numberConcurrentIOVs_ != 0);
       auto iter = std::lower_bound(forceNumberOfConcurrentIOVs_.begin(),
                                    forceNumberOfConcurrentIOVs_.end(),
                                    std::make_pair(eventSetupKey, 0u),
                                    [](auto const& left, auto const& right) { return left.first < right.first; });
       if (iter != forceNumberOfConcurrentIOVs_.end() && iter->first == eventSetupKey) {
         if (printInfoMsg && iter->second > maxConcurrentIOVs_) {
           LogInfo("Configuration") << "For record " << eventSetupKey.name() << " you have configured " << iter->second
                                    << " concurrent IOVs.\n"
                                    << "But you cannot have more concurrent IOVs than lumis or streams.\n"
                                    << "There will not be more than " << maxConcurrentIOVs_ << " concurrent IOVs.\n";
         }
         return std::min(iter->second, maxConcurrentIOVs_);
       }
       if (recordsNotAllowingConcurrentIOVs_.find(eventSetupKey) != recordsNotAllowingConcurrentIOVs_.end()) {
         return 1;
       }
       if (printInfoMsg && numberConcurrentIOVs_ > maxConcurrentIOVs_) {
         LogInfo("Configuration") << "For record " << eventSetupKey.name() << " you have configured "
                                  << numberConcurrentIOVs_ << " concurrent IOVs.\n"
                                  << "But you cannot have more concurrent IOVs than lumis or streams.\n"
                                  << "There will not be more than " << maxConcurrentIOVs_ << " concurrent IOVs.\n";
       }
       return numberConcurrentIOVs_;
     }

References cms::cuda::assert(), forceNumberOfConcurrentIOVs_, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, maxConcurrentIOVs_, min(), edm::eventsetup::EventSetupRecordKey::name(), numberConcurrentIOVs_, and recordsNotAllowingConcurrentIOVs_.

Referenced by edm::eventsetup::EventSetupProvider::finishConfiguration(), and edm::eventsetup::EventSetupsController::initializeEventSetupRecordIOVQueues().

◆ readConfigurationParameters()

void edm::eventsetup::NumberOfConcurrentIOVs::readConfigurationParameters	(	ParameterSet const *	eventSetupPset,
		unsigned int	maxConcurrentIOVs,
		bool	dumpOptions
	)

Definition at line 19 of file NumberOfConcurrentIOVs.cc.

                                                                                {
       if (eventSetupPset) {  // this condition is false for SubProcesses
         maxConcurrentIOVs_ = maxConcurrentIOVs;
         numberConcurrentIOVs_ = eventSetupPset->getUntrackedParameter<unsigned int>("numberOfConcurrentIOVs");
         if (numberConcurrentIOVs_ == 0 || numberConcurrentIOVs_ > maxConcurrentIOVs) {
           numberConcurrentIOVs_ = maxConcurrentIOVs;
         }
         if (dumpOptions) {
           LogAbsolute("Options") << "Number of Concurrent IOVs = " << numberConcurrentIOVs_;
         }
  
         ParameterSet const& pset(eventSetupPset->getUntrackedParameterSet("forceNumberOfConcurrentIOVs"));
         std::vector<std::string> recordNames = pset.getParameterNames();
         forceNumberOfConcurrentIOVs_.reserve(recordNames.size());
         for (auto const& recordName : recordNames) {
           EventSetupRecordKey recordKey(eventsetup::EventSetupRecordKey::TypeTag::findType(recordName));
           forceNumberOfConcurrentIOVs_.emplace_back(recordKey, pset.getUntrackedParameter<unsigned int>(recordName));
         }
         std::sort(forceNumberOfConcurrentIOVs_.begin(),
                   forceNumberOfConcurrentIOVs_.end(),
                   [](auto const& left, auto const& right) { return left.first < right.first; });
       }
     }