Inheritance diagram for edmtest::ConcurrentIOVESSource:

Public Member Functions
	ConcurrentIOVESSource (edm::ParameterSet const &)

std::unique_ptr< IOVTestInfo >	produce (ESTestRecordI const &)

std::unique_ptr< ESTestDataA >	produceA (ESTestRecordA const &)

Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
bool	concurrentFinder () const

const eventsetup::ComponentDescription &	descriptionForFinder () const

	EventSetupRecordIntervalFinder ()

	EventSetupRecordIntervalFinder (const EventSetupRecordIntervalFinder &)=delete

std::set< eventsetup::EventSetupRecordKey >	findingForRecords () const

const ValidityInterval &	findIntervalFor (const eventsetup::EventSetupRecordKey &, const IOVSyncValue &)

bool	nonconcurrentAndIOVNeedsUpdate (const eventsetup::EventSetupRecordKey &key, const IOVSyncValue &syncValue) const

const EventSetupRecordIntervalFinder &	operator= (const EventSetupRecordIntervalFinder &)=delete

void	resetInterval (const eventsetup::EventSetupRecordKey &)

void	setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)

virtual	~EventSetupRecordIntervalFinder () noexcept(false)

Public Member Functions inherited from edm::ESProducer
	ESProducer ()

	ESProducer (const ESProducer &)=delete

ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const

ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const

bool	hasMayConsumes () const noexcept

size_t	numberOfTokenIndices (unsigned int iIndex) const

ESProducer const &	operator= (const ESProducer &)=delete

SerialTaskQueueChain &	queue ()

template<typename Record >
std::optional< std::vector< ESProxyIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final

	~ESProducer () noexcept(false) override

Public Member Functions inherited from edm::ESProxyFactoryProducer
	ESProxyFactoryProducer ()

	ESProxyFactoryProducer (const ESProxyFactoryProducer &)=delete

const ESProxyFactoryProducer &	operator= (const ESProxyFactoryProducer &)=delete

	~ESProxyFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
void	createKeyedProxies (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

	DataProxyProvider ()

	DataProxyProvider (const DataProxyProvider &)=delete

const ComponentDescription &	description () const

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const DataProxyProvider &	operator= (const DataProxyProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::eventsetup::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)

Private Member Functions
bool	isConcurrentFinder () const override

void	setIntervalFor (edm::eventsetup::EventSetupRecordKey const &, edm::IOVSyncValue const &, edm::ValidityInterval &) override

Private Attributes
const bool	concurrentFinder_

const bool	findForRecordA_

const bool	iovIsTime_

std::set< edm::IOVSyncValue >	setOfInvalidIOV_

std::set< edm::IOVSyncValue >	setOfIOV_

const bool	testForceESSourceMode_

edm::ValidityInterval	validityInterval_

edm::WallclockTimer	wallclockTimer_

Additional Inherited Members
Protected Types inherited from edm::ESProxyFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

Protected Types inherited from edm::eventsetup::DataProxyProvider
using	KeyedProxiesVector = std::vector< std::pair< DataKey, std::shared_ptr< DataProxy > >>

Protected Member Functions inherited from edm::EventSetupRecordIntervalFinder
template<class T >
void	findingRecord ()

void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)

Protected Member Functions inherited from edm::ESProducer
template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord , typename TArg >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})

template<typename TFunc >
auto	setWhatProduced (TFunc &&func, const es::Label &iLabel={})

template<typename TReturn , typename TRecord , typename TFunc , typename TDecorator >
ESConsumesCollectorT< TRecord >	setWhatProduced (TFunc &&func, TDecorator &&iDec, const es::Label &iLabel={})

void	usesResources (std::vector< std::string > const &)

Protected Member Functions inherited from edm::ESProxyFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedProxiesVector	registerProxies (const EventSetupRecordKey &, unsigned int iovIndex) override

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Detailed Description

Definition at line 35 of file ConcurrentIOVESSource.cc.

Constructor & Destructor Documentation

◆ ConcurrentIOVESSource()

edmtest::ConcurrentIOVESSource::ConcurrentIOVESSource ( edm::ParameterSet const & pset )

Definition at line 68 of file ConcurrentIOVESSource.cc.

References findForRecordA_, iovIsTime_, produceA(), muonDTDigis_cfi::pset, setOfInvalidIOV_, setOfIOV_, edm::ESProducer::setWhatProduced(), edm::WallclockTimer::start(), groupFilesInBlocks::temp, heppy_batch::val, and wallclockTimer_.

       : iovIsTime_(!pset.getParameter<bool>("iovIsRunNotTime")),
         concurrentFinder_(pset.getParameter<bool>("concurrentFinder")),
         testForceESSourceMode_(pset.getParameter<bool>("testForceESSourceMode")),
         findForRecordA_(pset.getParameter<bool>("findForRecordA")) {
     wallclockTimer_.start();
 
     std::vector<unsigned int> temp(pset.getParameter<std::vector<unsigned int>>("firstValidLumis"));
     for (auto val : temp) {
       if (iovIsTime_) {
         setOfIOV_.insert(edm::IOVSyncValue(edm::Timestamp(val)));
       } else {
         setOfIOV_.insert(edm::IOVSyncValue(edm::EventID(1, val, 0)));
       }
     }
 
     std::vector<unsigned int> tempInvalid(pset.getParameter<std::vector<unsigned int>>("invalidLumis"));
     for (auto val : tempInvalid) {
       if (iovIsTime_) {
         setOfInvalidIOV_.insert(edm::IOVSyncValue(edm::Timestamp(val)));
       } else {
         setOfInvalidIOV_.insert(edm::IOVSyncValue(edm::EventID(1, val, 0)));
       }
     }
     this->findingRecord<ESTestRecordI>();
     setWhatProduced(this);
     if (findForRecordA_) {
       this->findingRecord<ESTestRecordA>();
       setWhatProduced(this, &ConcurrentIOVESSource::produceA);
     }
   }

Member Function Documentation

◆ fillDescriptions()

void edmtest::ConcurrentIOVESSource::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 138 of file ConcurrentIOVESSource.cc.

References edm::ConfigurationDescriptions::addDefault(), and submitPVResolutionJobs::desc.

                                                                                          {
     edm::ParameterSetDescription desc;
     std::vector<unsigned int> emptyVector;
     desc.add<bool>("iovIsRunNotTime", true);
     desc.add<bool>("concurrentFinder", true);
     desc.add<bool>("testForceESSourceMode", false);
     desc.add<bool>("findForRecordA", false);
     desc.add<std::vector<unsigned int>>("firstValidLumis", emptyVector);
     desc.add<std::vector<unsigned int>>("invalidLumis", emptyVector);
     descriptions.addDefault(desc);
   }

◆ isConcurrentFinder()

bool edmtest::ConcurrentIOVESSource::isConcurrentFinder ( ) const

inlineoverrideprivatevirtual

Reimplemented from edm::EventSetupRecordIntervalFinder.

Definition at line 49 of file ConcurrentIOVESSource.cc.

References concurrentFinder_.

49 { return concurrentFinder_; }

edmtest::ConcurrentIOVESSource::concurrentFinder_

const bool concurrentFinder_

Definition: ConcurrentIOVESSource.cc:56

◆ produce()

std::unique_ptr< IOVTestInfo > edmtest::ConcurrentIOVESSource::produce ( ESTestRecordI const & record )

Definition at line 100 of file ConcurrentIOVESSource.cc.

References concurrentFinder_, data, Exception, edm::WallclockTimer::realTime(), AlCaHarvesting_cff::record, validityInterval_, and wallclockTimer_.

                                                                                        {
     auto data = std::make_unique<IOVTestInfo>();
 
     edm::ValidityInterval iov = record.validityInterval();
     edm::LogAbsolute("ConcurrentIOVESSource")
         << "ConcurrentIOVESSource::produce startIOV = " << iov.first().luminosityBlockNumber()
         << " endIOV = " << iov.last().luminosityBlockNumber() << " IOV index = " << record.iovIndex()
         << " cache identifier = " << record.cacheIdentifier() << " time = " << wallclockTimer_.realTime();
 
     if (!concurrentFinder_) {
       if (validityInterval_ != iov) {
         throw cms::Exception("TestError")
             << "ConcurrentIOVESSource::produce, testing as nonconcurrent finder and IOV changed!";
       }
     }
 
     data->iovStartLumi_ = iov.first().luminosityBlockNumber();
     data->iovEndLumi_ = iov.last().luminosityBlockNumber();
     data->iovIndex_ = record.iovIndex();
     data->cacheIdentifier_ = record.cacheIdentifier();
     return data;
   }

◆ produceA()

std::unique_ptr< ESTestDataA > edmtest::ConcurrentIOVESSource::produceA ( ESTestRecordA const & record )

Definition at line 123 of file ConcurrentIOVESSource.cc.

References Exception, edm::ValidityInterval::first(), edm::ValidityInterval::last(), edm::IOVSyncValue::luminosityBlockNumber(), edm::WallclockTimer::realTime(), AlCaHarvesting_cff::record, testForceESSourceMode_, and wallclockTimer_.

Referenced by ConcurrentIOVESSource().

                                                                                         {
     edm::ValidityInterval iov = record.validityInterval();
     if (!testForceESSourceMode_ && record.iovIndex() != 0) {
       // This criteria should never fail because the EventSetupRecord class
       // is hard coded to allow only one IOV at a time.
       throw cms::Exception("TestError")
           << "ConcurrentIOVESSource::produce, more than one concurrent IOV for type ESTestRecordA!";
     }
     edm::LogAbsolute("ConcurrentIOVESSource")
         << "ConcurrentIOVESSource::produceA startIOV = " << iov.first().luminosityBlockNumber()
         << " endIOV = " << iov.last().luminosityBlockNumber() << " IOV index = " << record.iovIndex()
         << " cache identifier = " << record.cacheIdentifier() << " time = " << wallclockTimer_.realTime();
     return std::make_unique<ESTestDataA>(0);
   }

◆ setIntervalFor()

void edmtest::ConcurrentIOVESSource::setIntervalFor	(	edm::eventsetup::EventSetupRecordKey const &	key,
		edm::IOVSyncValue const &	syncValue,
		edm::ValidityInterval &	interval
	)

overrideprivatevirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 150 of file ConcurrentIOVESSource.cc.

References edm::IOVSyncValue::endOfTime(), writeEcalDQMStatus::interval, edm::ValidityInterval::invalidInterval(), iovIsTime_, edm::EventID::maxEventNumber(), setOfInvalidIOV_, setOfIOV_, and validityInterval_.

                                                                             {
     interval = edm::ValidityInterval::invalidInterval();
     validityInterval_ = interval;
 
     for (auto const& invalidSyncValue : setOfInvalidIOV_) {
       if (syncValue == invalidSyncValue) {
         return;
       }
     }
 
     //if no intervals given, fail immediately
     if (setOfIOV_.empty()) {
       return;
     }
 
     std::pair<std::set<edm::IOVSyncValue>::iterator, std::set<edm::IOVSyncValue>::iterator> itFound =
         setOfIOV_.equal_range(syncValue);
 
     if (itFound.first == itFound.second) {
       if (itFound.first == setOfIOV_.begin()) {
         //request is before first valid interval, so fail
         return;
       }
       //go back one step
       --itFound.first;
     }
     edm::IOVSyncValue endOfInterval = edm::IOVSyncValue::endOfTime();
 
     if (itFound.second != setOfIOV_.end()) {
       if (iovIsTime_) {
         endOfInterval = edm::IOVSyncValue(edm::Timestamp(itFound.second->time().value() - 1));
       } else {
         endOfInterval = edm::IOVSyncValue(
             edm::EventID(1, itFound.second->eventID().luminosityBlock() - 1, edm::EventID::maxEventNumber()));
       }
     }
     interval = edm::ValidityInterval(*(itFound.first), endOfInterval);
     validityInterval_ = interval;
   }

Member Data Documentation

◆ concurrentFinder_

const bool edmtest::ConcurrentIOVESSource::concurrentFinder_

private

Definition at line 56 of file ConcurrentIOVESSource.cc.

Referenced by isConcurrentFinder(), and produce().

◆ findForRecordA_

const bool edmtest::ConcurrentIOVESSource::findForRecordA_

private

Definition at line 58 of file ConcurrentIOVESSource.cc.

Referenced by ConcurrentIOVESSource().

◆ iovIsTime_

const bool edmtest::ConcurrentIOVESSource::iovIsTime_

private

Definition at line 53 of file ConcurrentIOVESSource.cc.

Referenced by ConcurrentIOVESSource(), and setIntervalFor().

◆ setOfInvalidIOV_

std::set<edm::IOVSyncValue> edmtest::ConcurrentIOVESSource::setOfInvalidIOV_

private

Definition at line 55 of file ConcurrentIOVESSource.cc.

Referenced by ConcurrentIOVESSource(), and setIntervalFor().

◆ setOfIOV_

std::set<edm::IOVSyncValue> edmtest::ConcurrentIOVESSource::setOfIOV_

private

Definition at line 54 of file ConcurrentIOVESSource.cc.

Referenced by ConcurrentIOVESSource(), and setIntervalFor().

◆ testForceESSourceMode_

const bool edmtest::ConcurrentIOVESSource::testForceESSourceMode_

private

Definition at line 57 of file ConcurrentIOVESSource.cc.

Referenced by produceA().

◆ validityInterval_

edm::ValidityInterval edmtest::ConcurrentIOVESSource::validityInterval_

private

Definition at line 65 of file ConcurrentIOVESSource.cc.

Referenced by produce(), and setIntervalFor().

◆ wallclockTimer_

edm::WallclockTimer edmtest::ConcurrentIOVESSource::wallclockTimer_

private

Definition at line 59 of file ConcurrentIOVESSource.cc.

Referenced by ConcurrentIOVESSource(), produce(), and produceA().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ConcurrentIOVESSource()

Member Function Documentation

◆ fillDescriptions()

◆ isConcurrentFinder()

◆ produce()

◆ produceA()

◆ setIntervalFor()

Member Data Documentation

◆ concurrentFinder_

◆ findForRecordA_

◆ iovIsTime_

◆ setOfInvalidIOV_

◆ setOfIOV_

◆ testForceESSourceMode_

◆ validityInterval_

◆ wallclockTimer_