File indexing completed on 2023-03-17 11:02:15
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/DataProxyProvider.h"
0028 #include "FWCore/Framework/interface/DataProxy.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<DataProxyProvider> iProvider) {
0055 assert(iProvider->isUsingRecord(key_));
0056 edm::propagate_const<std::shared_ptr<DataProxyProvider>> 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::addProxiesToRecordHelper, 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::addProxiesToRecord(std::shared_ptr<DataProxyProvider> iProvider,
0117 const EventSetupRecordProvider::DataToPreferredProviderMap& iMap) {
0118 typedef DataProxyProvider::KeyedProxies ProxyList;
0119 typedef EventSetupRecordProvider::DataToPreferredProviderMap PreferredMap;
0120
0121 for (auto& record : recordImpls_) {
0122 ProxyList& keyedProxies(iProvider->keyedProxies(this->key(), record.iovIndex()));
0123
0124 for (auto keyedProxy : keyedProxies) {
0125 PreferredMap::const_iterator itFound = iMap.find(keyedProxy.dataKey_);
0126 if (iMap.end() != itFound) {
0127 if (itFound->second.type_ != keyedProxy.dataProxy_->providerDescription()->type_ ||
0128 itFound->second.label_ != keyedProxy.dataProxy_->providerDescription()->label_) {
0129
0130 continue;
0131 }
0132 }
0133 record.add(keyedProxy.dataKey_, keyedProxy.dataProxy_);
0134 }
0135 }
0136 }
0137
0138 void EventSetupRecordProvider::initializeForNewIOV(unsigned int iovIndex, unsigned long long cacheIdentifier) {
0139 EventSetupRecordImpl* impl = &recordImpls_[iovIndex];
0140 recordImpl_ = impl;
0141 bool hasFinder = finder_.get() != nullptr;
0142 impl->initializeForNewIOV(cacheIdentifier, validityInterval_, hasFinder);
0143 eventSetupImpl_->addRecordImpl(*recordImpl_);
0144 }
0145
0146 void EventSetupRecordProvider::continueIOV(bool newEventSetupImpl) {
0147 if (intervalStatus_ == IntervalStatus::UpdateIntervalEnd) {
0148 recordImpl_->setSafely(validityInterval_);
0149 }
0150 if (newEventSetupImpl && intervalStatus_ != IntervalStatus::Invalid) {
0151 eventSetupImpl_->addRecordImpl(*recordImpl_);
0152 }
0153 }
0154
0155 void EventSetupRecordProvider::endIOV(unsigned int iovIndex) { recordImpls_[iovIndex].invalidateProxies(); }
0156
0157 void EventSetupRecordProvider::initializeForNewSyncValue() {
0158 intervalStatus_ = IntervalStatus::NotInitializedForSyncValue;
0159 }
0160
0161 bool EventSetupRecordProvider::doWeNeedToWaitForIOVsToFinish(IOVSyncValue const& iTime) const {
0162 if (!hasNonconcurrentFinder_) {
0163 return false;
0164 }
0165 if (intervalStatus_ == IntervalStatus::Invalid || !validityInterval_.validFor(iTime)) {
0166 return finder_->nonconcurrentAndIOVNeedsUpdate(key_, iTime);
0167 }
0168 return false;
0169 }
0170
0171 bool EventSetupRecordProvider::setValidityIntervalFor(const IOVSyncValue& iTime) {
0172
0173
0174
0175
0176
0177
0178
0179
0180
0181 if (intervalStatus_ == IntervalStatus::NotInitializedForSyncValue) {
0182 intervalStatus_ = IntervalStatus::Invalid;
0183
0184 if (validityInterval_.first() != IOVSyncValue::invalidIOVSyncValue() && validityInterval_.validFor(iTime)) {
0185 intervalStatus_ = IntervalStatus::SameInterval;
0186
0187 } else if (finder_.get() != nullptr) {
0188 IOVSyncValue oldFirst(validityInterval_.first());
0189 IOVSyncValue oldLast(validityInterval_.last());
0190 validityInterval_ = finder_->findIntervalFor(key_, iTime);
0191
0192
0193
0194
0195
0196 if (validityInterval_.first() != IOVSyncValue::invalidIOVSyncValue()) {
0197
0198 if (validityInterval_.first() != oldFirst) {
0199 intervalStatus_ = IntervalStatus::NewInterval;
0200
0201
0202
0203
0204 } else if (validityInterval_.last() != oldLast) {
0205 intervalStatus_ = IntervalStatus::UpdateIntervalEnd;
0206 } else {
0207 intervalStatus_ = IntervalStatus::SameInterval;
0208 }
0209 }
0210 }
0211 }
0212 return intervalStatus_ != IntervalStatus::Invalid;
0213 }
0214
0215 void EventSetupRecordProvider::resetProxies() {
0216
0217 for (auto& recordImplIter : recordImpls_) {
0218 recordImplIter.invalidateProxies();
0219 recordImplIter.resetIfTransientInProxies();
0220 }
0221
0222
0223 validityInterval_ = ValidityInterval{};
0224 if (finder_.get() != nullptr) {
0225 finder_->resetInterval(key_);
0226 }
0227 }
0228
0229 void EventSetupRecordProvider::getReferencedESProducers(
0230 std::map<EventSetupRecordKey, std::vector<ComponentDescription const*>>& referencedESProducers) const {
0231 firstRecordImpl().getESProducers(referencedESProducers[key_]);
0232 }
0233
0234 void EventSetupRecordProvider::fillReferencedDataKeys(
0235 std::map<DataKey, ComponentDescription const*>& referencedDataKeys) const {
0236 std::vector<DataKey> keys;
0237 firstRecordImpl().fillRegisteredDataKeys(keys);
0238 std::vector<ComponentDescription const*> components = firstRecordImpl().componentsForRegisteredDataKeys();
0239 auto itComponents = components.begin();
0240 for (auto const& k : keys) {
0241 referencedDataKeys.emplace(k, *itComponents);
0242 ++itComponents;
0243 }
0244 }
0245
0246 void EventSetupRecordProvider::resetRecordToProxyPointers(DataToPreferredProviderMap const& iMap) {
0247 for (auto& recordImplIter : recordImpls_) {
0248 recordImplIter.clearProxies();
0249 }
0250 using std::placeholders::_1;
0251 for_all(providers_, std::bind(&EventSetupRecordProvider::addProxiesToRecordHelper, this, _1, iMap));
0252 }
0253
0254 std::set<EventSetupRecordKey> EventSetupRecordProvider::dependentRecords() const { return dependencies(key()); }
0255
0256 std::set<ComponentDescription> EventSetupRecordProvider::proxyProviderDescriptions() const {
0257 using std::placeholders::_1;
0258 std::set<ComponentDescription> descriptions;
0259 std::transform(providers_.begin(),
0260 providers_.end(),
0261 std::inserter(descriptions, descriptions.end()),
0262 std::bind(&DataProxyProvider::description, _1));
0263 return descriptions;
0264 }
0265
0266 std::shared_ptr<DataProxyProvider> EventSetupRecordProvider::proxyProvider(ComponentDescription const& iDesc) {
0267 using std::placeholders::_1;
0268 auto itFound = std::find_if(
0269 providers_.begin(),
0270 providers_.end(),
0271 std::bind(std::equal_to<ComponentDescription>(), iDesc, std::bind(&DataProxyProvider::description, _1)));
0272 if (itFound == providers_.end()) {
0273 return std::shared_ptr<DataProxyProvider>();
0274 }
0275 return get_underlying_safe(*itFound);
0276 }
0277
0278 std::shared_ptr<DataProxyProvider> EventSetupRecordProvider::proxyProvider(ParameterSetIDHolder const& psetID) {
0279 for (auto& dataProxyProvider : providers_) {
0280 if (dataProxyProvider->description().pid_ == psetID.psetID()) {
0281 return get_underlying_safe(dataProxyProvider);
0282 }
0283 }
0284 return std::shared_ptr<DataProxyProvider>();
0285 }
0286
0287 void EventSetupRecordProvider::resetProxyProvider(
0288 ParameterSetIDHolder const& psetID, std::shared_ptr<DataProxyProvider> const& sharedDataProxyProvider) {
0289 for (auto& dataProxyProvider : providers_) {
0290 if (dataProxyProvider->description().pid_ == psetID.psetID()) {
0291 dataProxyProvider = sharedDataProxyProvider;
0292 dataProxyProvider->createKeyedProxies(key_, nConcurrentIOVs_);
0293 }
0294 }
0295 }
0296
0297 std::vector<DataKey> EventSetupRecordProvider::registeredDataKeys() const {
0298 std::vector<DataKey> ret;
0299 firstRecordImpl().fillRegisteredDataKeys(ret);
0300 return ret;
0301 }
0302
0303 std::vector<ComponentDescription const*> EventSetupRecordProvider::componentsForRegisteredDataKeys() const {
0304 return firstRecordImpl().componentsForRegisteredDataKeys();
0305 }
0306
0307 }
0308 }