Inheritance diagram for edmtest::TestESConcurrentSource:

Public Types
using	EventSetupRecordKey = edm::eventsetup::EventSetupRecordKey

Public Member Functions
void	busyWait (char const *msg) const

void	incrementCount ()

	TestESConcurrentSource (edm::ParameterSet const &)

	~TestESConcurrentSource () override

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

const ComponentDescription &	description () const

	ESProductResolverProvider ()

	ESProductResolverProvider (const ESProductResolverProvider &)=delete

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

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedResolvers &	keyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const ESProductResolverProvider &	operator= (const ESProductResolverProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

virtual void	updateLookup (ESRecordsToProductResolverIndices const &)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~ESProductResolverProvider () noexcept(false)

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)

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

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

Public Attributes
std::atomic< unsigned int >	count_

std::atomic< unsigned int >	count_initializeForNewIOV_

std::atomic< unsigned int >	count_setIntervalFor_

std::atomic< unsigned int >	maxCount_

Private Member Functions
void	initConcurrentIOVs (EventSetupRecordKey const &, unsigned int nConcurrentIOVs) override

bool	isConcurrentFinder () const override

KeyedResolversVector	registerResolvers (EventSetupRecordKey const &, unsigned int iovIndex) override

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

Private Attributes
bool	checkIOVInitialization_

unsigned int	expectedNumberOfConcurrentIOVs_

const unsigned int	iterations_

unsigned int	nConcurrentIOVs_ = 0

const double	pi_

std::set< edm::IOVSyncValue >	setOfIOV_

Additional Inherited Members
Protected Types inherited from edm::eventsetup::ESProductResolverProvider
using	KeyedResolversVector = std::vector< std::pair< DataKey, std::shared_ptr< ESProductResolver > >>

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

void	usingRecordWithKey (const EventSetupRecordKey &key)

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

void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)

Detailed Description

Definition at line 55 of file TestESConcurrentSource.cc.

Member Typedef Documentation

◆ EventSetupRecordKey

using edmtest::TestESConcurrentSource::EventSetupRecordKey = edm::eventsetup::EventSetupRecordKey

Definition at line 58 of file TestESConcurrentSource.cc.

Constructor & Destructor Documentation

◆ TestESConcurrentSource()

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

explicit

Definition at line 122 of file TestESConcurrentSource.cc.

References muonDTDigis_cfi::pset, setOfIOV_, groupFilesInBlocks::temp, and heppy_batch::val.

       : count_(0),
         maxCount_(0),
         count_setIntervalFor_(0),
         count_initializeForNewIOV_(0),
         iterations_(pset.getParameter<unsigned int>("iterations")),
         pi_(std::acos(-1)),
         expectedNumberOfConcurrentIOVs_(pset.getParameter<unsigned int>("expectedNumberOfConcurrentIOVs")),
         checkIOVInitialization_(pset.getParameter<bool>("checkIOVInitialization")) {
     std::vector<unsigned int> temp(pset.getParameter<std::vector<unsigned int>>("firstValidLumis"));
     for (auto val : temp) {
       setOfIOV_.insert(edm::IOVSyncValue(edm::EventID(1, val, 0)));
     }
 
     findingRecord<ESTestRecordI>();
     usingRecord<ESTestRecordI>();
   }

◆ ~TestESConcurrentSource()

edmtest::TestESConcurrentSource::~TestESConcurrentSource ( )

override

Definition at line 140 of file TestESConcurrentSource.cc.

References maxCount_.

                                                   {
     edm::LogAbsolute("TestESConcurrentSource") << "max concurrency seen " << maxCount_.load();
   }

Member Function Documentation

◆ busyWait()

void edmtest::TestESConcurrentSource::busyWait ( char const * msg ) const

Definition at line 234 of file TestESConcurrentSource.cc.

References funct::cos(), mps_fire::i, iterations_, mps_check::msg, and pi_.

Referenced by edmtest::TestESConcurrentSourceTestResolver::prefetch(), and setIntervalFor().

                                                              {
     edm::LogAbsolute("TestESConcurrentSource::busyWait") << "Start TestESConcurrentSource::busyWait " << msg;
     double sum = 0.;
     const double stepSize = pi_ / iterations_;
     for (unsigned int i = 0; i < iterations_; ++i) {
       sum += stepSize * cos(i * stepSize);
     }
     edm::LogAbsolute("TestESConcurrentSource::busyWait")
         << "Stop TestESConcurrentSource::busyWait " << msg << " " << sum;
   }

◆ fillDescriptions()

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

static

Definition at line 144 of file TestESConcurrentSource.cc.

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

                                                                                           {
     edm::ParameterSetDescription desc;
     std::vector<unsigned int> emptyVector;
     desc.add<unsigned int>("iterations", 10 * 1000 * 1000);
     desc.add<bool>("checkIOVInitialization", false);
     desc.add<unsigned int>("expectedNumberOfConcurrentIOVs", 0);
     desc.add<std::vector<unsigned int>>("firstValidLumis", emptyVector);
     descriptions.addDefault(desc);
   }

◆ incrementCount()

void edmtest::TestESConcurrentSource::incrementCount ( )

inline

Definition at line 66 of file TestESConcurrentSource.cc.

References count_, visualization-live-secondInstance_cfg::m, maxCount_, and findQualityFiles::v.

Referenced by edmtest::TestESConcurrentSourceTestResolver::prefetch(), and setIntervalFor().

                           {
       auto const v = ++count_;
       auto m = maxCount_.load();
       while (m < v) {
         maxCount_.compare_exchange_strong(m, v);
       }
     }

◆ initConcurrentIOVs()

void edmtest::TestESConcurrentSource::initConcurrentIOVs	(	EventSetupRecordKey const &	key,
		unsigned int	nConcurrentIOVs
	)

overrideprivatevirtual

Reimplemented from edm::eventsetup::ESProductResolverProvider.

Definition at line 220 of file TestESConcurrentSource.cc.

References Exception, expectedNumberOfConcurrentIOVs_, submitPVResolutionJobs::key, and nConcurrentIOVs_.

                                                                                                               {
     edm::LogAbsolute("TestESConcurrentSource::initConcurrentIOVs")
         << "Start TestESConcurrentSource::initConcurrentIOVs " << nConcurrentIOVs << " " << key.name();
     if (EventSetupRecordKey::makeKey<ESTestRecordI>() != key) {
       throw cms::Exception("TestFailure") << "TestESConcurrentSource::initConcurrentIOVs,"
                                           << " unexpected EventSetupRecordKey";
     }
     if (expectedNumberOfConcurrentIOVs_ != 0 && nConcurrentIOVs != expectedNumberOfConcurrentIOVs_) {
       throw cms::Exception("TestFailure") << "TestESConcurrentSource::initConcurrentIOVs,"
                                           << " unexpected number of concurrent IOVs";
     }
     nConcurrentIOVs_ = nConcurrentIOVs;
   }

◆ isConcurrentFinder()

bool edmtest::TestESConcurrentSource::isConcurrentFinder ( ) const

inlineoverrideprivatevirtual

Reimplemented from edm::EventSetupRecordIntervalFinder.

Definition at line 79 of file TestESConcurrentSource.cc.

79 { return true; }

◆ registerResolvers()

edm::eventsetup::ESProductResolverProvider::KeyedResolversVector edmtest::TestESConcurrentSource::registerResolvers	(	EventSetupRecordKey const &	,
		unsigned int	iovIndex
	)

overrideprivatevirtual

Implements edm::eventsetup::ESProductResolverProvider.

Definition at line 198 of file TestESConcurrentSource.cc.

References Exception, expectedNumberOfConcurrentIOVs_, and nConcurrentIOVs_.

                                                          {
     if (expectedNumberOfConcurrentIOVs_ != 0 && nConcurrentIOVs_ != expectedNumberOfConcurrentIOVs_) {
       throw cms::Exception("TestFailure") << "TestESConcurrentSource::registerResolvers,"
                                           << " unexpected number of concurrent IOVs";
     }
     KeyedResolversVector keyedResolversVector;
 
     {
       edm::eventsetup::DataKey dataKey(edm::eventsetup::DataKey::makeTypeTag<IOVTestInfo>(),
                                        edm::eventsetup::IdTags(""));
       keyedResolversVector.emplace_back(dataKey, std::make_shared<TestESConcurrentSourceTestResolver>(this));
     }
     {
       edm::eventsetup::DataKey dataKey(edm::eventsetup::DataKey::makeTypeTag<IOVTestInfo>(),
                                        edm::eventsetup::IdTags("other"));
       keyedResolversVector.emplace_back(dataKey, std::make_shared<TestESConcurrentSourceTestResolver>(this));
     }
 
     return keyedResolversVector;
   }

◆ setIntervalFor()

void edmtest::TestESConcurrentSource::setIntervalFor	(	EventSetupRecordKey const &	,
		edm::IOVSyncValue const &	syncValue,
		edm::ValidityInterval &	iov
	)

overrideprivatevirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 154 of file TestESConcurrentSource.cc.

References busyWait(), checkIOVInitialization_, count_, count_initializeForNewIOV_, count_setIntervalFor_, edm::IOVSyncValue::endOfTime(), Exception, incrementCount(), edm::ValidityInterval::invalidInterval(), edm::EventID::maxEventNumber(), and setOfIOV_.

                                                                         {
     if (checkIOVInitialization_) {
       // Note that this check should pass with the specific configuration where I enable
       // the check, but in general it does not have to be true. The counts are offset
       // by 1 because the beginRun IOV is invalid (no IOV initialization).
       if (count_setIntervalFor_ > 0 && count_initializeForNewIOV_ != 2 * (count_setIntervalFor_ - 1)) {
         throw cms::Exception("TestFailure") << "TestESConcurrentSource::setIntervalFor,"
                                             << " unexpected number of IOV initializations";
       }
     }
     incrementCount();
     ++count_setIntervalFor_;
     busyWait("setIntervalFor");
     iov = edm::ValidityInterval::invalidInterval();
 
     if (setOfIOV_.empty()) {
       --count_;
       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
         --count_;
         return;
       }
       //go back one step
       --itFound.first;
     }
 
     edm::IOVSyncValue endOfInterval = edm::IOVSyncValue::endOfTime();
     if (itFound.second != setOfIOV_.end()) {
       endOfInterval = edm::IOVSyncValue(
           edm::EventID(1, itFound.second->eventID().luminosityBlock() - 1, edm::EventID::maxEventNumber()));
     }
     iov = edm::ValidityInterval(*(itFound.first), endOfInterval);
     --count_;
   }

Member Data Documentation

◆ checkIOVInitialization_

bool edmtest::TestESConcurrentSource::checkIOVInitialization_

private

Definition at line 89 of file TestESConcurrentSource.cc.

Referenced by setIntervalFor().

◆ count_

std::atomic<unsigned int> edmtest::TestESConcurrentSource::count_

Definition at line 73 of file TestESConcurrentSource.cc.

Referenced by incrementCount(), edmtest::TestESConcurrentSourceTestResolver::prefetch(), and setIntervalFor().

◆ count_initializeForNewIOV_

std::atomic<unsigned int> edmtest::TestESConcurrentSource::count_initializeForNewIOV_

Definition at line 76 of file TestESConcurrentSource.cc.

Referenced by edmtest::TestESConcurrentSourceTestResolver::initializeForNewIOV(), and setIntervalFor().

◆ count_setIntervalFor_

std::atomic<unsigned int> edmtest::TestESConcurrentSource::count_setIntervalFor_

Definition at line 75 of file TestESConcurrentSource.cc.

Referenced by setIntervalFor().

◆ expectedNumberOfConcurrentIOVs_

unsigned int edmtest::TestESConcurrentSource::expectedNumberOfConcurrentIOVs_

private

Definition at line 87 of file TestESConcurrentSource.cc.

Referenced by initConcurrentIOVs(), and registerResolvers().

◆ iterations_

const unsigned int edmtest::TestESConcurrentSource::iterations_

private

Definition at line 85 of file TestESConcurrentSource.cc.

Referenced by busyWait().

◆ maxCount_

std::atomic<unsigned int> edmtest::TestESConcurrentSource::maxCount_

Definition at line 74 of file TestESConcurrentSource.cc.

Referenced by incrementCount(), and ~TestESConcurrentSource().

◆ nConcurrentIOVs_

unsigned int edmtest::TestESConcurrentSource::nConcurrentIOVs_ = 0

private

Definition at line 88 of file TestESConcurrentSource.cc.

Referenced by initConcurrentIOVs(), and registerResolvers().

◆ pi_

const double edmtest::TestESConcurrentSource::pi_

private

Definition at line 86 of file TestESConcurrentSource.cc.

Referenced by busyWait().

◆ setOfIOV_

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

private

Definition at line 84 of file TestESConcurrentSource.cc.

Referenced by setIntervalFor(), and TestESConcurrentSource().

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ EventSetupRecordKey

Constructor & Destructor Documentation

◆ TestESConcurrentSource()

◆ ~TestESConcurrentSource()

Member Function Documentation

◆ busyWait()

◆ fillDescriptions()

◆ incrementCount()

◆ initConcurrentIOVs()

◆ isConcurrentFinder()

◆ registerResolvers()

◆ setIntervalFor()

Member Data Documentation

◆ checkIOVInitialization_

◆ count_

◆ count_initializeForNewIOV_

◆ count_setIntervalFor_

◆ expectedNumberOfConcurrentIOVs_

◆ iterations_

◆ maxCount_

◆ nConcurrentIOVs_

◆ pi_

◆ setOfIOV_