edm::eventsetup::NumberOfConcurrentIOVs Class Reference

#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.

: numberConcurrentIOVs_(1) {}

Member Function Documentation

clear()

void edm::eventsetup::NumberOfConcurrentIOVs::clear

(

void

)

Definition at line 77 of file NumberOfConcurrentIOVs.cc.

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

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

                                       {
      // Mark this as invalid
      numberConcurrentIOVs_ = 0;

      // Free up memory
      recordsNotAllowingConcurrentIOVs_.clear();
      std::vector<std::pair<EventSetupRecordKey, unsigned int>>().swap(forceNumberOfConcurrentIOVs_);
    }

fillRecordsNotAllowingConcurrentIOVs()

void edm::eventsetup::NumberOfConcurrentIOVs::fillRecordsNotAllowingConcurrentIOVs

(

EventSetupProvider const &

eventSetupProvider

)

Definition at line 45 of file NumberOfConcurrentIOVs.cc.

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

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

                                                                                                                  {
      eventSetupProvider.fillRecordsNotAllowingConcurrentIOVs(recordsNotAllowingConcurrentIOVs_);
    }

numberOfConcurrentIOVs()

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

Definition at line 49 of file NumberOfConcurrentIOVs.cc.

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

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

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

readConfigurationParameters()

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

Definition at line 19 of file NumberOfConcurrentIOVs.cc.

References edm::eventsetup::heterocontainer::HCTypeTag::findType(), forceNumberOfConcurrentIOVs_, edm::ParameterSet::getUntrackedParameter(), edm::ParameterSet::getUntrackedParameterSet(), maxConcurrentIOVs_, numberConcurrentIOVs_, muonDTDigis_cfi::pset, align_cfg::recordName, and jetUpdater_cfi::sort.

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

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

Member Data Documentation

forceNumberOfConcurrentIOVs_

std::vector<std::pair<EventSetupRecordKey, unsigned int> > edm::eventsetup::NumberOfConcurrentIOVs::forceNumberOfConcurrentIOVs_

private

Definition at line 76 of file NumberOfConcurrentIOVs.h.

Referenced by clear(), numberOfConcurrentIOVs(), and readConfigurationParameters().

maxConcurrentIOVs_

unsigned int edm::eventsetup::NumberOfConcurrentIOVs::maxConcurrentIOVs_ = 1

private

Definition at line 78 of file NumberOfConcurrentIOVs.h.

Referenced by numberOfConcurrentIOVs(), and readConfigurationParameters().

numberConcurrentIOVs_

unsigned int edm::eventsetup::NumberOfConcurrentIOVs::numberConcurrentIOVs_

private

Definition at line 56 of file NumberOfConcurrentIOVs.h.

Referenced by clear(), numberOfConcurrentIOVs(), and readConfigurationParameters().

recordsNotAllowingConcurrentIOVs_

std::set<EventSetupRecordKey> edm::eventsetup::NumberOfConcurrentIOVs::recordsNotAllowingConcurrentIOVs_

private

Definition at line 67 of file NumberOfConcurrentIOVs.h.

Referenced by clear(), fillRecordsNotAllowingConcurrentIOVs(), and numberOfConcurrentIOVs().