File indexing completed on 2024-12-10 23:21:46
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014 #include <algorithm>
0015 #include <cassert>
0016
0017
0018 #include "FWCore/Framework/interface/EventSetupRecordProvider.h"
0019
0020 #include "FWCore/Framework/interface/ParameterSetIDHolder.h"
0021 #include "FWCore/Framework/interface/EventSetupImpl.h"
0022 #include "FWCore/Framework/interface/EventSetupProvider.h"
0023 #include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
0024 #include "FWCore/Framework/src/IntersectingIOVRecordIntervalFinder.h"
0025 #include "FWCore/Framework/interface/DependentRecordIntervalFinder.h"
0026 #include "FWCore/Framework/interface/RecordDependencyRegister.h"
0027 #include "FWCore/Framework/interface/ESProductResolverProvider.h"
0028 #include "FWCore/Framework/interface/ESProductResolver.h"
0029 #include "FWCore/Framework/interface/EventSetupRecord.h"
0030 #include "FWCore/Utilities/interface/Algorithms.h"
0031 #include "FWCore/Utilities/interface/Exception.h"
0032 #include "make_shared_noexcept_false.h"
0033
0034 namespace edm {
0035 namespace eventsetup {
0036
0037 EventSetupRecordProvider::EventSetupRecordProvider(const EventSetupRecordKey& iKey,
0038 ActivityRegistry const* activityRegistry,
0039 unsigned int nConcurrentIOVs)
0040 : key_(iKey),
0041 validityInterval_(),
0042 finder_(),
0043 providers_(),
0044 multipleFinders_(new std::vector<edm::propagate_const<std::shared_ptr<EventSetupRecordIntervalFinder>>>()),
0045 nConcurrentIOVs_(nConcurrentIOVs) {
0046 recordImpls_.reserve(nConcurrentIOVs);
0047 for (unsigned int i = 0; i < nConcurrentIOVs_; ++i) {
0048 recordImpls_.emplace_back(iKey, activityRegistry, i);
0049 }
0050 }
0051
0052 EventSetupRecordImpl const& EventSetupRecordProvider::firstRecordImpl() const { return recordImpls_[0]; }
0053
0054 void EventSetupRecordProvider::add(std::shared_ptr<ESProductResolverProvider> iProvider) {
0055 assert(iProvider->isUsingRecord(key_));
0056 edm::propagate_const<std::shared_ptr<ESProductResolverProvider>> pProvider(iProvider);
0057 assert(!search_all(providers_, pProvider));
0058 providers_.emplace_back(iProvider);
0059 }
0060
0061 void EventSetupRecordProvider::addFinder(std::shared_ptr<EventSetupRecordIntervalFinder> iFinder) {
0062 auto oldFinder = finder();
0063 finder_ = iFinder;
0064 if (nullptr != multipleFinders_.get()) {
0065 multipleFinders_->emplace_back(iFinder);
0066 } else {
0067
0068
0069 if (nullptr != oldFinder.get()) {
0070 cms::Exception("EventSetupMultipleSources")
0071 << "An additional source has been added to the Record " << key_.name() << "'\n"
0072 << "after all the other sources have been dealt with. This is a logic error, please send email to the "
0073 "framework group.";
0074 }
0075 }
0076 }
0077 void EventSetupRecordProvider::setValidityInterval_forTesting(const ValidityInterval& iInterval) {
0078 validityInterval_ = iInterval;
0079 initializeForNewSyncValue();
0080 }
0081
0082 void EventSetupRecordProvider::setDependentProviders(
0083 const std::vector<std::shared_ptr<EventSetupRecordProvider>>& iProviders) {
0084 using std::placeholders::_1;
0085 std::shared_ptr<DependentRecordIntervalFinder> newFinder =
0086 make_shared_noexcept_false<DependentRecordIntervalFinder>(key());
0087
0088 std::shared_ptr<EventSetupRecordIntervalFinder> old = swapFinder(newFinder);
0089
0090 for (auto const& p : iProviders) {
0091 newFinder->addProviderWeAreDependentOn(p);
0092 };
0093
0094
0095 if (old.get() != nullptr) {
0096 newFinder->setAlternateFinder(old);
0097 }
0098 }
0099 void EventSetupRecordProvider::usePreferred(const DataToPreferredProviderMap& iMap) {
0100 using std::placeholders::_1;
0101 for_all(providers_, std::bind(&EventSetupRecordProvider::addResolversToRecordHelper, this, _1, iMap));
0102 if (1 < multipleFinders_->size()) {
0103 std::shared_ptr<IntersectingIOVRecordIntervalFinder> intFinder =
0104 make_shared_noexcept_false<IntersectingIOVRecordIntervalFinder>(key_);
0105 intFinder->swapFinders(*multipleFinders_);
0106 finder_ = intFinder;
0107 }
0108 if (finder_) {
0109 hasNonconcurrentFinder_ = !finder_->concurrentFinder();
0110 }
0111
0112
0113 multipleFinders_.reset(nullptr);
0114 }
0115
0116 void EventSetupRecordProvider::addResolversToRecord(
0117 std::shared_ptr<ESProductResolverProvider> iProvider,
0118 const EventSetupRecordProvider::DataToPreferredProviderMap& iMap) {
0119 typedef ESProductResolverProvider::KeyedResolvers ResolverList;
0120 typedef EventSetupRecordProvider::DataToPreferredProviderMap PreferredMap;
0121
0122 for (auto& record : recordImpls_) {
0123 ResolverList& keyedResolvers(iProvider->keyedResolvers(this->key(), record.iovIndex()));
0124
0125 for (auto keyedResolver : keyedResolvers) {
0126 PreferredMap::const_iterator itFound = iMap.find(keyedResolver.dataKey_);
0127 if (iMap.end() != itFound) {
0128 if (itFound->second.type_ != keyedResolver.productResolver_->providerDescription()->type_ ||
0129 itFound->second.label_ != keyedResolver.productResolver_->providerDescription()->label_) {
0130
0131 continue;
0132 }
0133 }
0134 record.add(keyedResolver.dataKey_, keyedResolver.productResolver_);
0135 }
0136 }
0137 }
0138
0139 void EventSetupRecordProvider::initializeForNewIOV(unsigned int iovIndex, unsigned long long cacheIdentifier) {
0140 EventSetupRecordImpl* impl = &recordImpls_[iovIndex];
0141 recordImpl_ = impl;
0142 bool hasFinder = finder_.get() != nullptr;
0143 impl->initializeForNewIOV(cacheIdentifier, validityInterval_, hasFinder);
0144 eventSetupImpl_->addRecordImpl(*recordImpl_);
0145 }
0146
0147 void EventSetupRecordProvider::continueIOV(bool newEventSetupImpl) {
0148 if (intervalStatus_ == IntervalStatus::UpdateIntervalEnd) {
0149 recordImpl_->setSafely(validityInterval_);
0150 }
0151 if (newEventSetupImpl && intervalStatus_ != IntervalStatus::Invalid) {
0152 eventSetupImpl_->addRecordImpl(*recordImpl_);
0153 }
0154 }
0155
0156 void EventSetupRecordProvider::endIOV(unsigned int iovIndex) { recordImpls_[iovIndex].invalidateResolvers(); }
0157
0158 void EventSetupRecordProvider::initializeForNewSyncValue() {
0159 intervalStatus_ = IntervalStatus::NotInitializedForSyncValue;
0160 }
0161
0162 bool EventSetupRecordProvider::doWeNeedToWaitForIOVsToFinish(IOVSyncValue const& iTime) const {
0163 if (!hasNonconcurrentFinder_) {
0164 return false;
0165 }
0166 if (intervalStatus_ == IntervalStatus::Invalid || !validityInterval_.validFor(iTime)) {
0167 return finder_->nonconcurrentAndIOVNeedsUpdate(key_, iTime);
0168 }
0169 return false;
0170 }
0171
0172 bool EventSetupRecordProvider::setValidityIntervalFor(const IOVSyncValue& iTime) {
0173
0174
0175
0176
0177
0178
0179
0180
0181
0182 if (intervalStatus_ == IntervalStatus::NotInitializedForSyncValue) {
0183 intervalStatus_ = IntervalStatus::Invalid;
0184
0185 if (validityInterval_.first() != IOVSyncValue::invalidIOVSyncValue() && validityInterval_.validFor(iTime)) {
0186 intervalStatus_ = IntervalStatus::SameInterval;
0187
0188 } else if (finder_.get() != nullptr) {
0189 IOVSyncValue oldFirst(validityInterval_.first());
0190 IOVSyncValue oldLast(validityInterval_.last());
0191 validityInterval_ = finder_->findIntervalFor(key_, iTime);
0192
0193
0194
0195
0196
0197 if (validityInterval_.first() != IOVSyncValue::invalidIOVSyncValue()) {
0198
0199 if (validityInterval_.first() != oldFirst) {
0200 intervalStatus_ = IntervalStatus::NewInterval;
0201
0202
0203
0204
0205 } else if (validityInterval_.last() != oldLast) {
0206 intervalStatus_ = IntervalStatus::UpdateIntervalEnd;
0207 } else {
0208 intervalStatus_ = IntervalStatus::SameInterval;
0209 }
0210 }
0211 }
0212 }
0213 return intervalStatus_ != IntervalStatus::Invalid;
0214 }
0215
0216 void EventSetupRecordProvider::resetResolvers() {
0217
0218 for (auto& recordImplIter : recordImpls_) {
0219 recordImplIter.invalidateResolvers();
0220 recordImplIter.resetIfTransientInResolvers();
0221 }
0222
0223
0224 validityInterval_ = ValidityInterval{};
0225 if (finder_.get() != nullptr) {
0226 finder_->resetInterval(key_);
0227 }
0228 }
0229
0230 void EventSetupRecordProvider::getReferencedESProducers(
0231 std::map<EventSetupRecordKey, std::vector<ComponentDescription const*>>& referencedESProducers) const {
0232 firstRecordImpl().getESProducers(referencedESProducers[key_]);
0233 }
0234
0235 void EventSetupRecordProvider::fillReferencedDataKeys(
0236 std::map<DataKey, ComponentDescription const*>& referencedDataKeys) const {
0237 std::vector<DataKey> keys;
0238 firstRecordImpl().fillRegisteredDataKeys(keys);
0239 std::vector<ComponentDescription const*> components = firstRecordImpl().componentsForRegisteredDataKeys();
0240 auto itComponents = components.begin();
0241 for (auto const& k : keys) {
0242 referencedDataKeys.emplace(k, *itComponents);
0243 ++itComponents;
0244 }
0245 }
0246
0247 void EventSetupRecordProvider::resetRecordToResolverPointers(DataToPreferredProviderMap const& iMap) {
0248 for (auto& recordImplIter : recordImpls_) {
0249 recordImplIter.clearResolvers();
0250 }
0251 using std::placeholders::_1;
0252 for_all(providers_, std::bind(&EventSetupRecordProvider::addResolversToRecordHelper, this, _1, iMap));
0253 }
0254
0255 void EventSetupRecordProvider::updateLookup(ESRecordsToProductResolverIndices const& iResolverToIndices) {
0256 for (auto& productResolverProvider : providers_) {
0257 productResolverProvider->updateLookup(iResolverToIndices);
0258 }
0259 }
0260
0261 std::set<EventSetupRecordKey> EventSetupRecordProvider::dependentRecords() const { return dependencies(key()); }
0262
0263 std::set<ComponentDescription> EventSetupRecordProvider::resolverProviderDescriptions() const {
0264 using std::placeholders::_1;
0265 std::set<ComponentDescription> descriptions;
0266 std::transform(providers_.begin(),
0267 providers_.end(),
0268 std::inserter(descriptions, descriptions.end()),
0269 std::bind(&ESProductResolverProvider::description, _1));
0270 return descriptions;
0271 }
0272
0273 std::shared_ptr<ESProductResolverProvider> EventSetupRecordProvider::resolverProvider(
0274 ComponentDescription const& iDesc) {
0275 using std::placeholders::_1;
0276 auto itFound = std::find_if(
0277 providers_.begin(),
0278 providers_.end(),
0279 std::bind(
0280 std::equal_to<ComponentDescription>(), iDesc, std::bind(&ESProductResolverProvider::description, _1)));
0281 if (itFound == providers_.end()) {
0282 return std::shared_ptr<ESProductResolverProvider>();
0283 }
0284 return get_underlying_safe(*itFound);
0285 }
0286
0287 std::shared_ptr<ESProductResolverProvider> EventSetupRecordProvider::resolverProvider(
0288 ParameterSetIDHolder const& psetID) {
0289 for (auto& productResolverProvider : providers_) {
0290 if (productResolverProvider->description().pid_ == psetID.psetID()) {
0291 return get_underlying_safe(productResolverProvider);
0292 }
0293 }
0294 return std::shared_ptr<ESProductResolverProvider>();
0295 }
0296
0297 void EventSetupRecordProvider::resetProductResolverProvider(
0298 ParameterSetIDHolder const& psetID,
0299 std::shared_ptr<ESProductResolverProvider> const& sharedESProductResolverProvider) {
0300 for (auto& productResolverProvider : providers_) {
0301 if (productResolverProvider->description().pid_ == psetID.psetID()) {
0302 productResolverProvider = sharedESProductResolverProvider;
0303 productResolverProvider->createKeyedResolvers(key_, nConcurrentIOVs_);
0304 }
0305 }
0306 }
0307
0308 std::vector<DataKey> EventSetupRecordProvider::registeredDataKeys() const {
0309 std::vector<DataKey> ret;
0310 firstRecordImpl().fillRegisteredDataKeys(ret);
0311 return ret;
0312 }
0313
0314 std::vector<ComponentDescription const*> EventSetupRecordProvider::componentsForRegisteredDataKeys() const {
0315 return firstRecordImpl().componentsForRegisteredDataKeys();
0316 }
0317
0318 }
0319 }