File indexing completed on 2023-01-11 16:27:14
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016 #include <algorithm>
0017 #include <cassert>
0018
0019
0020 #include "FWCore/Framework/interface/EventSetupProvider.h"
0021 #include "FWCore/Concurrency/interface/WaitingTaskList.h"
0022 #include "FWCore/Framework/interface/EventSetupImpl.h"
0023 #include "FWCore/Framework/interface/EventSetupRecordProvider.h"
0024 #include "FWCore/Framework/interface/EventSetupRecord.h"
0025 #include "FWCore/Framework/interface/DataProxyProvider.h"
0026 #include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
0027 #include "FWCore/Framework/interface/ModuleFactory.h"
0028 #include "FWCore/Framework/interface/ParameterSetIDHolder.h"
0029 #include "FWCore/Framework/interface/ESRecordsToProxyIndices.h"
0030 #include "FWCore/Framework/interface/EventSetupsController.h"
0031 #include "FWCore/Framework/interface/NumberOfConcurrentIOVs.h"
0032 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0033 #include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
0034 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0035 #include "FWCore/Utilities/interface/Algorithms.h"
0036 #include "FWCore/Utilities/interface/Exception.h"
0037
0038 namespace edm {
0039 namespace eventsetup {
0040
0041 EventSetupProvider::EventSetupProvider(ActivityRegistry const* activityRegistry,
0042 unsigned subProcessIndex,
0043 const PreferredProviderInfo* iInfo)
0044 : activityRegistry_(activityRegistry),
0045 mustFinishConfiguration_(true),
0046 subProcessIndex_(subProcessIndex),
0047 preferredProviderInfo_((nullptr != iInfo) ? (new PreferredProviderInfo(*iInfo)) : nullptr),
0048 finders_(new std::vector<std::shared_ptr<EventSetupRecordIntervalFinder>>()),
0049 dataProviders_(new std::vector<std::shared_ptr<DataProxyProvider>>()),
0050 referencedDataKeys_(new std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription const*>>),
0051 recordToFinders_(
0052 new std::map<EventSetupRecordKey, std::vector<std::shared_ptr<EventSetupRecordIntervalFinder>>>),
0053 psetIDToRecordKey_(new std::map<ParameterSetIDHolder, std::set<EventSetupRecordKey>>),
0054 recordToPreferred_(new std::map<EventSetupRecordKey, std::map<DataKey, ComponentDescription>>),
0055 recordsWithALooperProxy_(new std::set<EventSetupRecordKey>) {}
0056
0057 EventSetupProvider::~EventSetupProvider() { forceCacheClear(); }
0058
0059 std::shared_ptr<EventSetupRecordProvider>& EventSetupProvider::recordProvider(const EventSetupRecordKey& iKey) {
0060 auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), iKey);
0061 if (lb == recordKeys_.end() || iKey != *lb) {
0062 throw cms::Exception("LogicError") << "EventSetupProvider::recordProvider Could not find key\n"
0063 << "Should be impossible. Please contact Framework developer.\n";
0064 }
0065 auto index = std::distance(recordKeys_.begin(), lb);
0066 return recordProviders_[index];
0067 }
0068
0069 EventSetupRecordProvider* EventSetupProvider::tryToGetRecordProvider(const EventSetupRecordKey& iKey) {
0070 auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), iKey);
0071 if (lb == recordKeys_.end() || iKey != *lb) {
0072 return nullptr;
0073 }
0074 auto index = std::distance(recordKeys_.begin(), lb);
0075 return recordProviders_[index].get();
0076 }
0077
0078 void EventSetupProvider::insert(const EventSetupRecordKey& iKey,
0079 std::unique_ptr<EventSetupRecordProvider> iProvider) {
0080 auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), iKey);
0081 auto index = std::distance(recordKeys_.begin(), lb);
0082 if (lb == recordKeys_.end() || iKey != *lb) {
0083 recordKeys_.insert(lb, iKey);
0084 recordProviders_.insert(recordProviders_.begin() + index, std::move(iProvider));
0085 } else {
0086 recordProviders_[index] = std::move(iProvider);
0087 }
0088 }
0089
0090 void EventSetupProvider::add(std::shared_ptr<DataProxyProvider> iProvider) {
0091 assert(iProvider.get() != nullptr);
0092 dataProviders_->push_back(iProvider);
0093 if (activityRegistry_) {
0094 activityRegistry_->postESModuleRegistrationSignal_(iProvider->description());
0095 }
0096 }
0097
0098 void EventSetupProvider::replaceExisting(std::shared_ptr<DataProxyProvider> dataProxyProvider) {
0099 ParameterSetIDHolder psetID(dataProxyProvider->description().pid_);
0100 std::set<EventSetupRecordKey> const& keysForPSetID = (*psetIDToRecordKey_)[psetID];
0101 for (auto const& key : keysForPSetID) {
0102 recordProvider(key)->resetProxyProvider(psetID, dataProxyProvider);
0103 }
0104 }
0105
0106 void EventSetupProvider::add(std::shared_ptr<EventSetupRecordIntervalFinder> iFinder) {
0107 assert(iFinder.get() != nullptr);
0108 finders_->push_back(iFinder);
0109 }
0110
0111 using RecordProviders = std::vector<std::shared_ptr<EventSetupRecordProvider>>;
0112 using RecordToPreferred = std::map<EventSetupRecordKey, EventSetupRecordProvider::DataToPreferredProviderMap>;
0113
0114 static void preferEverything(const ComponentDescription& iComponent,
0115 const RecordProviders& iRecordProviders,
0116 RecordToPreferred& iReturnValue) {
0117
0118 bool foundProxyProvider = false;
0119 for (auto const& recordProvider : iRecordProviders) {
0120 std::set<ComponentDescription> components = recordProvider->proxyProviderDescriptions();
0121 if (components.find(iComponent) != components.end()) {
0122 std::shared_ptr<DataProxyProvider> proxyProv = recordProvider->proxyProvider(*(components.find(iComponent)));
0123 assert(proxyProv.get());
0124
0125 std::set<EventSetupRecordKey> records = proxyProv->usingRecords();
0126 for (auto const& recordKey : records) {
0127 unsigned int iovIndex = 0;
0128 DataProxyProvider::KeyedProxies& keyedProxies = proxyProv->keyedProxies(recordKey, iovIndex);
0129 if (!keyedProxies.unInitialized()) {
0130
0131 EventSetupRecordProvider::DataToPreferredProviderMap& dataToProviderMap = iReturnValue[recordKey];
0132
0133 for (auto keyedProxy : keyedProxies) {
0134 EventSetupRecordProvider::DataToPreferredProviderMap::iterator itFind =
0135 dataToProviderMap.find(keyedProxy.dataKey_);
0136 if (itFind != dataToProviderMap.end()) {
0137 throw cms::Exception("ESPreferConflict")
0138 << "Two providers have been set to be preferred for\n"
0139 << keyedProxy.dataKey_.type().name() << " \"" << keyedProxy.dataKey_.name().value() << "\""
0140 << "\n the providers are "
0141 << "\n 1) type=" << itFind->second.type_ << " label=\"" << itFind->second.label_ << "\""
0142 << "\n 2) type=" << iComponent.type_ << " label=\"" << iComponent.label_ << "\""
0143 << "\nPlease modify configuration so only one is preferred";
0144 }
0145 dataToProviderMap.insert(std::make_pair(keyedProxy.dataKey_, iComponent));
0146 }
0147 }
0148 }
0149 foundProxyProvider = true;
0150 break;
0151 }
0152 }
0153 if (!foundProxyProvider) {
0154 throw cms::Exception("ESPreferNoProvider")
0155 << "Could not make type=\"" << iComponent.type_ << "\" label=\"" << iComponent.label_
0156 << "\" a preferred Provider."
0157 << "\n Please check spelling of name, or that it was loaded into the job.";
0158 }
0159 }
0160
0161 void EventSetupProvider::determinePreferred() {
0162 using namespace edm::eventsetup;
0163 if (preferredProviderInfo_) {
0164 for (auto const& itInfo : *preferredProviderInfo_) {
0165 if (itInfo.second.empty()) {
0166
0167 preferEverything(itInfo.first, recordProviders_, *recordToPreferred_);
0168 } else {
0169 for (auto const& itRecData : itInfo.second) {
0170 std::string recordName = itRecData.first;
0171 EventSetupRecordKey recordKey(eventsetup::EventSetupRecordKey::TypeTag::findType(recordName));
0172 if (recordKey.type() == eventsetup::EventSetupRecordKey::TypeTag()) {
0173 throw cms::Exception("ESPreferUnknownRecord")
0174 << "Unknown record \"" << recordName
0175 << "\" used in es_prefer statement for type=" << itInfo.first.type_ << " label=\""
0176 << itInfo.first.label_ << "\"\n Please check spelling.";
0177
0178 }
0179
0180 EventSetupRecordProvider& recordProviderForKey = *recordProvider(recordKey);
0181
0182 std::set<ComponentDescription> components = recordProviderForKey.proxyProviderDescriptions();
0183 std::set<ComponentDescription>::iterator itProxyProv = components.find(itInfo.first);
0184 if (itProxyProv == components.end()) {
0185 throw cms::Exception("ESPreferWrongRecord")
0186 << "The type=" << itInfo.first.type_ << " label=\"" << itInfo.first.label_
0187 << "\" does not provide data for the Record " << recordName;
0188 }
0189
0190 eventsetup::TypeTag datumType = eventsetup::TypeTag::findType(itRecData.second.first);
0191 if (datumType == eventsetup::TypeTag()) {
0192
0193 throw cms::Exception("ESPreferWrongDataType")
0194 << "The es_prefer statement for type=" << itInfo.first.type_ << " label=\"" << itInfo.first.label_
0195 << "\" has the unknown data type \"" << itRecData.second.first << "\""
0196 << "\n Please check spelling";
0197 }
0198 eventsetup::DataKey datumKey(datumType, itRecData.second.second.c_str());
0199
0200
0201 std::shared_ptr<DataProxyProvider> proxyProv = recordProviderForKey.proxyProvider(*itProxyProv);
0202 unsigned int iovIndex = 0;
0203 const DataProxyProvider::KeyedProxies& keyedProxies = proxyProv->keyedProxies(recordKey, iovIndex);
0204 if (!keyedProxies.contains(datumKey)) {
0205 throw cms::Exception("ESPreferWrongData")
0206 << "The es_prefer statement for type=" << itInfo.first.type_ << " label=\"" << itInfo.first.label_
0207 << "\" specifies the data item \n"
0208 << " type=\"" << itRecData.second.first << "\" label=\"" << itRecData.second.second << "\""
0209 << " which is not provided. Please check spelling.";
0210 }
0211
0212 EventSetupRecordProvider::DataToPreferredProviderMap& dataToProviderMap =
0213 (*recordToPreferred_)[recordKey];
0214
0215 if (dataToProviderMap.end() != dataToProviderMap.find(datumKey)) {
0216 EventSetupRecordProvider::DataToPreferredProviderMap::iterator itFind =
0217 dataToProviderMap.find(datumKey);
0218 throw cms::Exception("ESPreferConflict")
0219 << "Two providers have been set to be preferred for\n"
0220 << datumKey.type().name() << " \"" << datumKey.name().value() << "\""
0221 << "\n the providers are "
0222 << "\n 1) type=" << itFind->second.type_ << " label=\"" << itFind->second.label_ << "\""
0223 << "\n 2) type=" << itProxyProv->type_ << " label=\"" << itProxyProv->label_ << "\""
0224 << "\nPlease modify configuration so only one is preferred";
0225 }
0226 dataToProviderMap.insert(std::make_pair(datumKey, *itProxyProv));
0227 }
0228 }
0229 }
0230 }
0231 }
0232
0233 void EventSetupProvider::finishConfiguration(NumberOfConcurrentIOVs const& numberOfConcurrentIOVs,
0234 bool& hasNonconcurrentFinder) {
0235
0236 recordToFinders_->clear();
0237 for (auto& finder : *finders_) {
0238 if (!finder->concurrentFinder()) {
0239 hasNonconcurrentFinder = true;
0240 }
0241
0242 const std::set<EventSetupRecordKey> recordsUsing = finder->findingForRecords();
0243
0244 for (auto const& key : recordsUsing) {
0245 (*recordToFinders_)[key].push_back(finder);
0246
0247 EventSetupRecordProvider* recProvider = tryToGetRecordProvider(key);
0248 if (recProvider == nullptr) {
0249 bool printInfoMsg = true;
0250 unsigned int nConcurrentIOVs = numberOfConcurrentIOVs.numberOfConcurrentIOVs(key, printInfoMsg);
0251
0252
0253 insert(key, std::make_unique<EventSetupRecordProvider>(key, activityRegistry_, nConcurrentIOVs));
0254 recProvider = tryToGetRecordProvider(key);
0255 }
0256 recProvider->addFinder(finder);
0257 }
0258 }
0259
0260 finders_.reset();
0261
0262
0263
0264 psetIDToRecordKey_->clear();
0265 for (auto& dataProxyProvider : *dataProviders_) {
0266 ParameterSetIDHolder psetID(dataProxyProvider->description().pid_);
0267
0268 const std::set<EventSetupRecordKey> recordsUsing = dataProxyProvider->usingRecords();
0269 for (auto const& key : recordsUsing) {
0270 unsigned int nConcurrentIOVs = numberOfConcurrentIOVs.numberOfConcurrentIOVs(key);
0271 dataProxyProvider->createKeyedProxies(key, nConcurrentIOVs);
0272
0273 if (dataProxyProvider->description().isLooper_) {
0274 recordsWithALooperProxy_->insert(key);
0275 }
0276
0277 (*psetIDToRecordKey_)[psetID].insert(key);
0278
0279 EventSetupRecordProvider* recProvider = tryToGetRecordProvider(key);
0280 if (recProvider == nullptr) {
0281 bool printInfoMsg = true;
0282 nConcurrentIOVs = numberOfConcurrentIOVs.numberOfConcurrentIOVs(key, printInfoMsg);
0283
0284 insert(key, std::make_unique<EventSetupRecordProvider>(key, activityRegistry_, nConcurrentIOVs));
0285 recProvider = tryToGetRecordProvider(key);
0286 }
0287 recProvider->add(dataProxyProvider);
0288 }
0289 }
0290
0291
0292 static const EventSetupRecordProvider::DataToPreferredProviderMap kEmptyMap;
0293
0294 determinePreferred();
0295
0296
0297
0298
0299 for (auto& itRecordProvider : recordProviders_) {
0300 const EventSetupRecordProvider::DataToPreferredProviderMap* preferredInfo = &kEmptyMap;
0301 RecordToPreferred::const_iterator itRecordFound = recordToPreferred_->find(itRecordProvider->key());
0302 if (itRecordFound != recordToPreferred_->end()) {
0303 preferredInfo = &(itRecordFound->second);
0304 }
0305
0306 itRecordProvider->usePreferred(*preferredInfo);
0307
0308 std::set<EventSetupRecordKey> records = itRecordProvider->dependentRecords();
0309 if (!records.empty()) {
0310 std::string missingRecords;
0311 std::vector<std::shared_ptr<EventSetupRecordProvider>> depProviders;
0312 depProviders.reserve(records.size());
0313 bool foundAllProviders = true;
0314 for (auto const& key : records) {
0315 auto lb = std::lower_bound(recordKeys_.begin(), recordKeys_.end(), key);
0316 if (lb == recordKeys_.end() || key != *lb) {
0317 foundAllProviders = false;
0318 if (missingRecords.empty()) {
0319 missingRecords = key.name();
0320 } else {
0321 missingRecords += ", ";
0322 missingRecords += key.name();
0323 }
0324 } else {
0325 auto index = std::distance(recordKeys_.begin(), lb);
0326 depProviders.push_back(recordProviders_[index]);
0327 }
0328 }
0329
0330 if (!foundAllProviders) {
0331 edm::LogInfo("EventSetupDependency")
0332 << "The EventSetup record " << itRecordProvider->key().name() << " depends on at least one Record \n ("
0333 << missingRecords
0334 << ") which is not present in the job."
0335 "\n This may lead to an exception begin thrown during event processing.\n If no exception occurs "
0336 "during the job than it is usually safe to ignore this message.";
0337
0338
0339
0340 }
0341
0342 itRecordProvider->setDependentProviders(depProviders);
0343 }
0344 }
0345
0346 auto indices = recordsToProxyIndices();
0347 for (auto& provider : *dataProviders_) {
0348 provider->updateLookup(indices);
0349 }
0350 dataProviders_.reset();
0351
0352 mustFinishConfiguration_ = false;
0353 }
0354
0355 using Itr = RecordProviders::iterator;
0356 static void findDependents(const EventSetupRecordKey& iKey,
0357 Itr itBegin,
0358 Itr itEnd,
0359 std::vector<std::shared_ptr<EventSetupRecordProvider>>& oDependents) {
0360 for (Itr it = itBegin; it != itEnd; ++it) {
0361
0362 const std::set<EventSetupRecordKey>& deps = (*it)->dependentRecords();
0363 if (deps.end() != deps.find(iKey)) {
0364 oDependents.push_back(*it);
0365
0366 findDependents((*it)->key(), itBegin, itEnd, oDependents);
0367 }
0368 }
0369 }
0370
0371 void EventSetupProvider::resetRecordPlusDependentRecords(const EventSetupRecordKey& iKey) {
0372 EventSetupRecordProvider* recProvider = tryToGetRecordProvider(iKey);
0373 if (recProvider == nullptr) {
0374 return;
0375 }
0376
0377 std::vector<std::shared_ptr<EventSetupRecordProvider>> dependents;
0378 findDependents(iKey, recordProviders_.begin(), recordProviders_.end(), dependents);
0379
0380 dependents.erase(std::unique(dependents.begin(), dependents.end()), dependents.end());
0381
0382 recProvider->resetProxies();
0383 for (auto& d : dependents) {
0384 d->resetProxies();
0385 }
0386 }
0387
0388 void EventSetupProvider::forceCacheClear() {
0389 for (auto& recProvider : recordProviders_) {
0390 if (recProvider) {
0391 recProvider->resetProxies();
0392 }
0393 }
0394 }
0395
0396 void EventSetupProvider::checkESProducerSharing(
0397 ModuleTypeResolverMaker const* resolverMaker,
0398 EventSetupProvider& precedingESProvider,
0399 std::set<ParameterSetIDHolder>& sharingCheckDone,
0400 std::map<EventSetupRecordKey, std::vector<ComponentDescription const*>>& referencedESProducers,
0401 EventSetupsController& esController) {
0402 edm::LogVerbatim("EventSetupSharing")
0403 << "EventSetupProvider::checkESProducerSharing: Checking processes with SubProcess Indexes "
0404 << subProcessIndex() << " and " << precedingESProvider.subProcessIndex();
0405
0406 if (referencedESProducers.empty()) {
0407 for (auto& recProvider : recordProviders_) {
0408 recProvider->getReferencedESProducers(referencedESProducers);
0409 }
0410 }
0411
0412
0413
0414
0415 std::map<EventSetupRecordKey, bool> allComponentsMatch;
0416
0417 std::map<ParameterSetID, bool> candidateNotRejectedYet;
0418
0419
0420
0421 for (auto const& iRecord : referencedESProducers) {
0422 for (auto const& iComponent : iRecord.second) {
0423 ParameterSetID const& psetID = iComponent->pid_;
0424 ParameterSetIDHolder psetIDHolder(psetID);
0425 if (sharingCheckDone.find(psetIDHolder) != sharingCheckDone.end())
0426 continue;
0427
0428 bool firstProcessWithThisPSet = false;
0429 bool precedingHasMatchingPSet = false;
0430
0431 esController.lookForMatches(psetID,
0432 subProcessIndex_,
0433 precedingESProvider.subProcessIndex_,
0434 firstProcessWithThisPSet,
0435 precedingHasMatchingPSet);
0436
0437 if (firstProcessWithThisPSet) {
0438 sharingCheckDone.insert(psetIDHolder);
0439 allComponentsMatch[iRecord.first] = false;
0440 continue;
0441 }
0442
0443 if (!precedingHasMatchingPSet) {
0444 allComponentsMatch[iRecord.first] = false;
0445 continue;
0446 }
0447
0448
0449
0450
0451
0452
0453
0454
0455
0456
0457
0458
0459
0460
0461 auto iCandidateNotRejectedYet = candidateNotRejectedYet.find(psetID);
0462 if (iCandidateNotRejectedYet == candidateNotRejectedYet.end()) {
0463 candidateNotRejectedYet[psetID] = true;
0464 iCandidateNotRejectedYet = candidateNotRejectedYet.find(psetID);
0465 }
0466
0467
0468
0469
0470
0471
0472
0473
0474
0475
0476
0477
0478
0479
0480
0481
0482
0483
0484
0485
0486 if (iCandidateNotRejectedYet->second == true) {
0487 auto iAllComponentsMatch = allComponentsMatch.find(iRecord.first);
0488 if (iAllComponentsMatch == allComponentsMatch.end()) {
0489
0490
0491
0492 bool match = doRecordsMatch(precedingESProvider, iRecord.first, allComponentsMatch, esController);
0493 allComponentsMatch[iRecord.first] = match;
0494 iAllComponentsMatch = allComponentsMatch.find(iRecord.first);
0495 }
0496 if (!iAllComponentsMatch->second) {
0497 iCandidateNotRejectedYet->second = false;
0498 }
0499 }
0500 }
0501 }
0502
0503
0504 for (auto const& candidate : candidateNotRejectedYet) {
0505 ParameterSetID const& psetID = candidate.first;
0506 bool canBeShared = candidate.second;
0507 if (canBeShared) {
0508 ParameterSet const& pset = esController.getESProducerPSet(psetID, subProcessIndex_);
0509 logInfoWhenSharing(pset);
0510 ParameterSetIDHolder psetIDHolder(psetID);
0511 sharingCheckDone.insert(psetIDHolder);
0512 if (esController.isFirstMatch(psetID, subProcessIndex_, precedingESProvider.subProcessIndex_)) {
0513 continue;
0514 }
0515
0516
0517
0518
0519 std::shared_ptr<DataProxyProvider> dataProxyProvider;
0520 std::set<EventSetupRecordKey> const& keysForPSetID1 = (*precedingESProvider.psetIDToRecordKey_)[psetIDHolder];
0521 for (auto const& key : keysForPSetID1) {
0522 dataProxyProvider = precedingESProvider.recordProvider(key)->proxyProvider(psetIDHolder);
0523 assert(dataProxyProvider);
0524 break;
0525 }
0526
0527 std::set<EventSetupRecordKey> const& keysForPSetID2 = (*psetIDToRecordKey_)[psetIDHolder];
0528 for (auto const& key : keysForPSetID2) {
0529 recordProvider(key)->resetProxyProvider(psetIDHolder, dataProxyProvider);
0530 }
0531 } else {
0532 if (esController.isLastMatch(psetID, subProcessIndex_, precedingESProvider.subProcessIndex_)) {
0533 ParameterSet& pset = esController.getESProducerPSet(psetID, subProcessIndex_);
0534 ModuleFactory::get()->addTo(esController, *this, pset, resolverMaker, true);
0535 }
0536 }
0537 }
0538 }
0539
0540 bool EventSetupProvider::doRecordsMatch(EventSetupProvider& precedingESProvider,
0541 EventSetupRecordKey const& eventSetupRecordKey,
0542 std::map<EventSetupRecordKey, bool>& allComponentsMatch,
0543 EventSetupsController const& esController) {
0544
0545
0546
0547
0548
0549
0550
0551
0552 if (precedingESProvider.recordsWithALooperProxy_->find(eventSetupRecordKey) !=
0553 precedingESProvider.recordsWithALooperProxy_->end()) {
0554 return false;
0555 }
0556
0557 if ((*recordToFinders_)[eventSetupRecordKey].size() !=
0558 (*precedingESProvider.recordToFinders_)[eventSetupRecordKey].size()) {
0559 return false;
0560 }
0561
0562 for (auto const& finder : (*recordToFinders_)[eventSetupRecordKey]) {
0563 ParameterSetID const& psetID = finder->descriptionForFinder().pid_;
0564 bool itMatches =
0565 esController.isMatchingESSource(psetID, subProcessIndex_, precedingESProvider.subProcessIndex_);
0566 if (!itMatches) {
0567 return false;
0568 }
0569 }
0570
0571 fillReferencedDataKeys(eventSetupRecordKey);
0572 precedingESProvider.fillReferencedDataKeys(eventSetupRecordKey);
0573
0574 std::map<DataKey, ComponentDescription const*> const& dataItems = (*referencedDataKeys_)[eventSetupRecordKey];
0575
0576 std::map<DataKey, ComponentDescription const*> const& precedingDataItems =
0577 (*precedingESProvider.referencedDataKeys_)[eventSetupRecordKey];
0578
0579 if (dataItems.size() != precedingDataItems.size()) {
0580 return false;
0581 }
0582
0583 for (auto const& dataItem : dataItems) {
0584 auto precedingDataItem = precedingDataItems.find(dataItem.first);
0585 if (precedingDataItem == precedingDataItems.end()) {
0586 return false;
0587 }
0588 if (dataItem.second->pid_ != precedingDataItem->second->pid_) {
0589 return false;
0590 }
0591
0592
0593
0594 if (!dataItem.second->isSource_ && !dataItem.second->isLooper_) {
0595 bool itMatches = esController.isMatchingESProducer(
0596 dataItem.second->pid_, subProcessIndex_, precedingESProvider.subProcessIndex_);
0597 if (!itMatches) {
0598 return false;
0599 }
0600 }
0601 }
0602 EventSetupRecordProvider* recProvider = tryToGetRecordProvider(eventSetupRecordKey);
0603 if (recProvider != nullptr) {
0604 std::set<EventSetupRecordKey> dependentRecords = recProvider->dependentRecords();
0605 for (auto const& dependentRecord : dependentRecords) {
0606 auto iter = allComponentsMatch.find(dependentRecord);
0607 if (iter != allComponentsMatch.end()) {
0608 if (iter->second) {
0609 continue;
0610 } else {
0611 return false;
0612 }
0613 }
0614 bool match = doRecordsMatch(precedingESProvider, dependentRecord, allComponentsMatch, esController);
0615 allComponentsMatch[dependentRecord] = match;
0616 if (!match)
0617 return false;
0618 }
0619 }
0620 return true;
0621 }
0622
0623 void EventSetupProvider::fillReferencedDataKeys(EventSetupRecordKey const& eventSetupRecordKey) {
0624 if (referencedDataKeys_->find(eventSetupRecordKey) != referencedDataKeys_->end())
0625 return;
0626
0627 EventSetupRecordProvider* recProvider = tryToGetRecordProvider(eventSetupRecordKey);
0628 if (recProvider == nullptr) {
0629 (*referencedDataKeys_)[eventSetupRecordKey];
0630 return;
0631 }
0632 recProvider->fillReferencedDataKeys((*referencedDataKeys_)[eventSetupRecordKey]);
0633 }
0634
0635 void EventSetupProvider::resetRecordToProxyPointers() {
0636 for (auto const& recProvider : recordProviders_) {
0637 static const EventSetupRecordProvider::DataToPreferredProviderMap kEmptyMap;
0638 const EventSetupRecordProvider::DataToPreferredProviderMap* preferredInfo = &kEmptyMap;
0639 RecordToPreferred::const_iterator itRecordFound = recordToPreferred_->find(recProvider->key());
0640 if (itRecordFound != recordToPreferred_->end()) {
0641 preferredInfo = &(itRecordFound->second);
0642 }
0643 recProvider->resetRecordToProxyPointers(*preferredInfo);
0644 }
0645 }
0646
0647 void EventSetupProvider::clearInitializationData() {
0648 preferredProviderInfo_.reset();
0649 referencedDataKeys_.reset();
0650 recordToFinders_.reset();
0651 psetIDToRecordKey_.reset();
0652 recordToPreferred_.reset();
0653 recordsWithALooperProxy_.reset();
0654 }
0655
0656 void EventSetupProvider::fillRecordsNotAllowingConcurrentIOVs(
0657 std::set<EventSetupRecordKey>& recordsNotAllowingConcurrentIOVs) const {
0658 for (auto const& dataProxyProvider : *dataProviders_) {
0659 dataProxyProvider->fillRecordsNotAllowingConcurrentIOVs(recordsNotAllowingConcurrentIOVs);
0660 }
0661 }
0662
0663 void EventSetupProvider::setAllValidityIntervals(const IOVSyncValue& iValue) {
0664
0665
0666
0667 for (auto& recProvider : recordProviders_) {
0668 recProvider->initializeForNewSyncValue();
0669 }
0670
0671 for (auto& recProvider : recordProviders_) {
0672 recProvider->setValidityIntervalFor(iValue);
0673 }
0674 }
0675
0676 std::shared_ptr<const EventSetupImpl> EventSetupProvider::eventSetupForInstance(const IOVSyncValue& iValue,
0677 bool& newEventSetupImpl) {
0678 using IntervalStatus = EventSetupRecordProvider::IntervalStatus;
0679
0680
0681
0682
0683
0684
0685 bool needNewEventSetupImpl = false;
0686 if (eventSetupImpl_.get() == nullptr) {
0687 needNewEventSetupImpl = true;
0688 } else {
0689 for (auto& recProvider : recordProviders_) {
0690 if (recProvider->intervalStatus() == IntervalStatus::Invalid) {
0691 if (eventSetupImpl_->validRecord(recProvider->key())) {
0692 needNewEventSetupImpl = true;
0693 }
0694 } else {
0695 if (recProvider->newIntervalForAnySubProcess()) {
0696 needNewEventSetupImpl = true;
0697 }
0698 }
0699 }
0700 }
0701
0702 if (needNewEventSetupImpl) {
0703
0704 eventSetupImpl_ = std::shared_ptr<EventSetupImpl>(new EventSetupImpl());
0705 newEventSetupImpl = true;
0706 eventSetupImpl_->setKeyIters(recordKeys_.begin(), recordKeys_.end());
0707
0708 for (auto& recProvider : recordProviders_) {
0709 recProvider->setEventSetupImpl(eventSetupImpl_.get());
0710 }
0711 }
0712 return get_underlying_safe(eventSetupImpl_);
0713 }
0714
0715 bool EventSetupProvider::doWeNeedToWaitForIOVsToFinish(IOVSyncValue const& iValue) const {
0716 for (auto& recProvider : recordProviders_) {
0717 if (recProvider->doWeNeedToWaitForIOVsToFinish(iValue)) {
0718 return true;
0719 }
0720 }
0721 return false;
0722 }
0723
0724 std::set<ComponentDescription> EventSetupProvider::proxyProviderDescriptions() const {
0725 typedef std::set<ComponentDescription> Set;
0726 Set descriptions;
0727
0728 for (auto const& recProvider : recordProviders_) {
0729 auto const& d = recProvider->proxyProviderDescriptions();
0730 descriptions.insert(d.begin(), d.end());
0731 }
0732 if (dataProviders_.get()) {
0733 for (auto const& p : *dataProviders_) {
0734 descriptions.insert(p->description());
0735 }
0736 }
0737
0738 return descriptions;
0739 }
0740
0741 void EventSetupProvider::addRecord(const EventSetupRecordKey& iKey) {
0742 insert(iKey, std::unique_ptr<EventSetupRecordProvider>());
0743 eventSetupImpl_->setKeyIters(recordKeys_.begin(), recordKeys_.end());
0744 }
0745
0746 void EventSetupProvider::setPreferredProviderInfo(PreferredProviderInfo const& iInfo) {
0747 preferredProviderInfo_ = std::make_unique<PreferredProviderInfo>(iInfo);
0748 }
0749
0750 void EventSetupProvider::fillKeys(std::set<EventSetupRecordKey>& keys) const {
0751 for (auto const& recProvider : recordProviders_) {
0752 keys.insert(recProvider->key());
0753 }
0754 }
0755
0756 ESRecordsToProxyIndices EventSetupProvider::recordsToProxyIndices() const {
0757 ESRecordsToProxyIndices ret(recordKeys_);
0758
0759 unsigned int index = 0;
0760 for (const auto& provider : recordProviders_) {
0761 index = ret.dataKeysInRecord(
0762 index, provider->key(), provider->registeredDataKeys(), provider->componentsForRegisteredDataKeys());
0763 }
0764
0765 return ret;
0766 }
0767
0768
0769
0770
0771 void EventSetupProvider::logInfoWhenSharing(ParameterSet const& iConfiguration) {
0772 std::string edmtype = iConfiguration.getParameter<std::string>("@module_edm_type");
0773 std::string modtype = iConfiguration.getParameter<std::string>("@module_type");
0774 std::string label = iConfiguration.getParameter<std::string>("@module_label");
0775 edm::LogVerbatim("EventSetupSharing")
0776 << "Sharing " << edmtype << ": class=" << modtype << " label='" << label << "'";
0777 }
0778
0779 }
0780 }