diff --git a/FWCore/Concurrency/scripts/edmStreamStallGrapher.py b/FWCore/Concurrency/scripts/edmStreamStallGrapher.py index 25bdf6a0bb61e..34ea19b1fd0ec 100755 --- a/FWCore/Concurrency/scripts/edmStreamStallGrapher.py +++ b/FWCore/Concurrency/scripts/edmStreamStallGrapher.py @@ -603,7 +603,7 @@ def plotPerStreamAboveFirstAndPrepareStack(points, allStackTimes, ax, stream, he allStackTimes[color].extend(theTS*(nthreads-threadOffset)) #---------------------------------------------- -# The same ES module can have multiple Proxies running concurrently +# The same ES module can have multiple Resolvers running concurrently # so we need to reference count the names of the active modules class RefCountSet(set): def __init__(self): diff --git a/FWCore/Framework/interface/CallbackBase.h b/FWCore/Framework/interface/CallbackBase.h index cec3d158fb14c..14caa130af7f7 100644 --- a/FWCore/Framework/interface/CallbackBase.h +++ b/FWCore/Framework/interface/CallbackBase.h @@ -68,7 +68,7 @@ namespace edm { class CallbackBase { public: CallbackBase(T* iProd, std::shared_ptr iProduceFunc, unsigned int iID, const TDecorator& iDec) - : proxyData_{}, + : resolverData_{}, producer_(iProd), callingContext_(&iProd->description(), iID), produceFunction_(std::move(iProduceFunc)), @@ -127,13 +127,13 @@ namespace edm { try { convertException::wrap([this, &serviceToken, &record, &eventSetupImpl, &produceFunctor] { ESModuleCallingContext const& context = callingContext_; - auto proxies = getTokenIndices(); + auto resolvers = getTokenIndices(); if (postMayGetResolvers_) { - proxies = &((*postMayGetResolvers_).front()); + resolvers = &((*postMayGetResolvers_).front()); } TRecord rec; ESParentContext pc{&context}; - rec.setImpl(record, transitionID(), proxies, eventSetupImpl, &pc); + rec.setImpl(record, transitionID(), resolvers, eventSetupImpl, &pc); ServiceRegistry::Operate operate(serviceToken.lock()); record->activityRegistry()->preESModuleSignal_.emit(record->key(), context); struct EndGuard { @@ -202,12 +202,12 @@ namespace edm { template void holdOntoPointer(DataT* iData) { - proxyData_[produce::find_index::value] = iData; + resolverData_[produce::find_index::value] = iData; } template void setData(ProductsT& iProducts) { - DataT* temp = reinterpret_cast(proxyData_[produce::find_index::value]); + DataT* temp = reinterpret_cast(resolverData_[produce::find_index::value]); if (nullptr != temp) { moveFromTo(iProducts, *temp); } @@ -243,14 +243,14 @@ namespace edm { void prefetchNeededDataAsync(WaitingTaskHolder task, EventSetupImpl const* iImpl, - ESResolverIndex const* proxies, + ESResolverIndex const* resolvers, ServiceToken const& token) const noexcept { auto recs = producer_->getTokenRecordIndices(id_); auto n = producer_->numberOfTokenIndices(id_); for (size_t i = 0; i != n; ++i) { auto rec = iImpl->findImpl(recs[i]); if (rec) { - rec->prefetchAsync(task, proxies[i], iImpl, token, ESParentContext{&callingContext_}); + rec->prefetchAsync(task, resolvers[i], iImpl, token, ESParentContext{&callingContext_}); } } } @@ -264,7 +264,7 @@ namespace edm { return static_cast(postMayGetResolvers_); } - std::array::value> proxyData_; + std::array::value> resolverData_; std::optional> postMayGetResolvers_; propagate_const producer_; ESModuleCallingContext callingContext_; diff --git a/FWCore/Framework/interface/CallbackExternalWork.h b/FWCore/Framework/interface/CallbackExternalWork.h index cbacdbc690564..a4acc2889c919 100644 --- a/FWCore/Framework/interface/CallbackExternalWork.h +++ b/FWCore/Framework/interface/CallbackExternalWork.h @@ -172,13 +172,13 @@ namespace edm { try { convertException::wrap([this, &holder, &serviceToken, &record, &eventSetupImpl] { ESModuleCallingContext const& context = Base::callingContext(); - auto proxies = Base::getTokenIndices(); + auto resolvers = Base::getTokenIndices(); if (Base::postMayGetResolvers()) { - proxies = &((*Base::postMayGetResolvers()).front()); + resolvers = &((*Base::postMayGetResolvers()).front()); } TRecord rec; edm::ESParentContext pc{&context}; - rec.setImpl(record, Base::transitionID(), proxies, eventSetupImpl, &pc); + rec.setImpl(record, Base::transitionID(), resolvers, eventSetupImpl, &pc); ServiceRegistry::Operate operate(serviceToken.lock()); record->activityRegistry()->preESModuleAcquireSignal_.emit(record->key(), context); struct EndGuard { diff --git a/FWCore/Framework/interface/ESProducer.h b/FWCore/Framework/interface/ESProducer.h index b1819c52a37ef..a5d833670eddf 100644 --- a/FWCore/Framework/interface/ESProducer.h +++ b/FWCore/Framework/interface/ESProducer.h @@ -16,11 +16,11 @@ set at run-time instead of compile time can be obtained by inheriting from ESProductResolverFactoryProducer instead.) If only one algorithm is being encapsulated then the user needs to - 1) add a method name 'produce' to the class. The 'produce' takes as its argument a const reference + 1) add a method named 'produce' to the class. The 'produce' takes as its argument a const reference to the record that is to hold the data item being produced. If only one data item is being produced, the 'produce' method must return either an 'std::unique_ptr' or 'std::shared_ptr' to the object being produced. (The choice depends on if the EventSetup or the ESProducer is managing the lifetime of - the object). If multiple items are being Produced they the 'produce' method must return an + the object). If multiple items are being Produced then the 'produce' method must return an ESProducts<> object which holds all of the items. 2) add 'setWhatProduced(this);' to their classes constructor diff --git a/FWCore/Framework/interface/ESProductResolver.h b/FWCore/Framework/interface/ESProductResolver.h index 470f94c329940..9017649780d1e 100644 --- a/FWCore/Framework/interface/ESProductResolver.h +++ b/FWCore/Framework/interface/ESProductResolver.h @@ -1,13 +1,13 @@ +// -*- C++ -*- #ifndef FWCore_Framework_ESProductResolver_h #define FWCore_Framework_ESProductResolver_h -// -*- C++ -*- // // Package: Framework // Class : ESProductResolver // /**\class edm::eventsetup::ESProductResolver - Description: Base class for data Proxies held by a EventSetupRecord + Description: Base class for product resolvers held by a EventSetupRecord Usage: This class defines the interface used to handle retrieving data from an diff --git a/FWCore/Framework/interface/ESProductResolverFactoryProducer.h b/FWCore/Framework/interface/ESProductResolverFactoryProducer.h index 6e84da1bb5ca2..cad950002accf 100644 --- a/FWCore/Framework/interface/ESProductResolverFactoryProducer.h +++ b/FWCore/Framework/interface/ESProductResolverFactoryProducer.h @@ -1,13 +1,13 @@ +// -*- C++ -*- #ifndef Framework_ESProductResolverFactoryProducer_h #define Framework_ESProductResolverFactoryProducer_h -// -*- C++ -*- // // Package: Framework // Class : ESProductResolverFactoryProducer // -/**\class ESProductResolverFactoryProducer ESProductResolverFactoryProducer.h FWCore/Framework/interface/ESProductResolverFactoryProducer.h +/**\class edm::ESProductResolverFactoryProducer - Description: An EventSetup algorithmic Provider that manages Factories of Proxies + Description: An EventSetup algorithmic Provider that manages Factories of Resolvers Usage: This class is used when the algorithms in the EventSetup that are to be run on demand are encapsulated @@ -15,7 +15,7 @@ directly in the Provider (see ESProducer for such an implemenation). Users inherit from this class and then call the 'registerFactory' method in their class' constructor - in order to get their Proxies registered. For most users, the already available templated Factory classes + in order to get their Resolvers registered. For most users, the already available templated Factory classes should suffice and therefore they should not need to create their own Factories. Example: register one Factory that creates a resolver that takes no arguments diff --git a/FWCore/Framework/interface/ESProductResolverProvider.h b/FWCore/Framework/interface/ESProductResolverProvider.h index 3c4aa09afb781..b7055edb6e903 100644 --- a/FWCore/Framework/interface/ESProductResolverProvider.h +++ b/FWCore/Framework/interface/ESProductResolverProvider.h @@ -1,6 +1,6 @@ +// -*- C++ -*- #ifndef FWCore_Framework_ESProductResolverProvider_h #define FWCore_Framework_ESProductResolverProvider_h -// -*- C++ -*- // // Package: Framework // Class : ESProductResolverProvider @@ -22,7 +22,7 @@ CondDBESSource is the main such class) then the registerResolvers function must be overridden. For the same EventSetupRecordKey, the vector returned should contain the same DataKeys in the same order for - all the different iovIndexes. DataProxies associated with the same + all the different iovIndexes. ESProductResolver's associated with the same EventSetupRecordKey should have caches that use different memory, but other than that they should also be the same. @@ -33,7 +33,7 @@ All other functions are intended for use by the Framework or tests and should not be called in classes derived from ESProductResolverProvider. They are primarily used when initializing the EventSetup system - so the DataProxies are available for use when needed. + so the ESProductResolver's are available for use when needed. */ // // Author: Chris Jones diff --git a/FWCore/Framework/interface/ESProductResolverTemplate.h b/FWCore/Framework/interface/ESProductResolverTemplate.h index 718760206b474..f4f4608ea76fe 100644 --- a/FWCore/Framework/interface/ESProductResolverTemplate.h +++ b/FWCore/Framework/interface/ESProductResolverTemplate.h @@ -1,13 +1,13 @@ +// -*- C++ -*- #ifndef FWCore_Framework_ESProductResolverTemplate_h #define FWCore_Framework_ESProductResolverTemplate_h -// -*- C++ -*- // // Package: Framework // Class : ESProductResolverTemplate // -/**\class ESProductResolverTemplate ESProductResolverTemplate.h FWCore/Framework/interface/ESProductResolverTemplate.h +/**\class edm::eventsetup::ESProductResolverTemplate - Description: A ESProductResolver base class which allows one to write type-safe proxies + Description: A ESProductResolver base class which allows one to write type-safe resolvers Note that ESProductResolver types that inherit from this are not allowed to get data from the EventSetup (they cannot consume anything). diff --git a/FWCore/Framework/interface/ESSourceConcurrentProductResolverTemplate.h b/FWCore/Framework/interface/ESSourceConcurrentProductResolverTemplate.h index 490e6a9357e69..406f4192740d8 100644 --- a/FWCore/Framework/interface/ESSourceConcurrentProductResolverTemplate.h +++ b/FWCore/Framework/interface/ESSourceConcurrentProductResolverTemplate.h @@ -1,13 +1,13 @@ +// -*- C++ -*- #ifndef FWCore_Framework_ESSourceConcurrentESProductResolverTemplate_h #define FWCore_Framework_ESSourceConcurrentESProductResolverTemplate_h -// -*- C++ -*- // // Package: FWCore/Framework // Class : ESSourceConcurrentESProductResolverTemplate // -/**\class ESSourceConcurrentESProductResolverTemplate ESSourceConcurrentESProductResolverTemplate.h "FWCore/Framework/interface/ESSourceConcurrentESProductResolverTemplate.h" +/**\class edm::eventsetup::ESSourceConcurrentESProductResolverTemplate - Description: An ESSource specific ESProductResolver which is type safe and can run concurrently with other DataProxies from the same ESSource. + Description: An ESSource specific ESProductResolver which is type safe and can run concurrently with other ESProductResolvers from the same ESSource. Usage: Inherit from this class and override diff --git a/FWCore/Framework/interface/ESSourceProductResolverBase.h b/FWCore/Framework/interface/ESSourceProductResolverBase.h index e3605f973a61d..d2514ac72c670 100644 --- a/FWCore/Framework/interface/ESSourceProductResolverBase.h +++ b/FWCore/Framework/interface/ESSourceProductResolverBase.h @@ -1,16 +1,17 @@ +// -*- C++ -*- #ifndef FWCore_Framework_ESSourceProductResolverBase_h #define FWCore_Framework_ESSourceProductResolverBase_h -// -*- C++ -*- // // Package: FWCore/Framework // Class : ESSourceProductResolverBase // -/**\class ESSourceProductResolverBase ESSourceProductResolverBase.h "FWCore/Framework/interface/ESSourceProductResolverBase.h" +/**\class edm::eventsetup::ESSourceProductResolverBase - Description: Base class for DataProxies for ESSources that can be specialized based on concurrency needs + Description: Base class for ESProductResolvers for ESSources that can be specialized based on concurrency needs Usage: - The ESSourceProductResolverBase provides the bases for DataProxies needed for ESSources. It allows customization of synchronization needs via the use of template parameters. + The ESSourceProductResolverBase provides the bases for ProductResolvers needed for ESSources. + It allows customization of synchronization needs via the use of template parameters. NOTE: if inheriting classes override `void invalidateCache()` they must be sure to call this classes implementation as part of the call. diff --git a/FWCore/Framework/interface/ESSourceProductResolverConcurrentBase.h b/FWCore/Framework/interface/ESSourceProductResolverConcurrentBase.h index 5984d35651956..a2177d8b95df4 100644 --- a/FWCore/Framework/interface/ESSourceProductResolverConcurrentBase.h +++ b/FWCore/Framework/interface/ESSourceProductResolverConcurrentBase.h @@ -1,16 +1,16 @@ +// -*- C++ -*- #ifndef FWCore_Framework_ESSourceProductResolverConcurrentBase_h #define FWCore_Framework_ESSourceProductResolverConcurrentBase_h -// -*- C++ -*- // // Package: FWCore/Framework // Class : ESSourceProductResolverConcurrentBase // -/**\class ESSourceProductResolverConcurrentBase ESSourceProductResolverConcurrentBase.h "FWCore/Framework/interface/ESSourceProductResolverConcurrentBase.h" +/**\class edm::eventsetup::ESSourceProductResolverConcurrentBase - Description: Base class for DataProxies for ESSources that require no synchronization + Description: Base class for ESProductResolver for ESSources that require no synchronization Usage: - The ESSourceProductResolverConcurrentBase allows DataProxies from the same ESSource to be called concurrently. + The ESSourceProductResolverConcurrentBase allows ESProductResolvers from the same ESSource to be called concurrently. NOTE: if inheriting classes override `void invalidateCache()` they must be sure to call this classes implementation as part of the call. diff --git a/FWCore/Framework/interface/ESSourceProductResolverNonConcurrentBase.h b/FWCore/Framework/interface/ESSourceProductResolverNonConcurrentBase.h index 23a1815eaee16..02372c97b2255 100644 --- a/FWCore/Framework/interface/ESSourceProductResolverNonConcurrentBase.h +++ b/FWCore/Framework/interface/ESSourceProductResolverNonConcurrentBase.h @@ -1,16 +1,16 @@ +// -*- C++ -*- #ifndef FWCore_Framework_ESSourceProductResolverNonConcurrentBase_h #define FWCore_Framework_ESSourceProductResolverNonConcurrentBase_h -// -*- C++ -*- // // Package: FWCore/Framework // Class : ESSourceProductResolverNonConcurrentBase // -/**\class ESSourceProductResolverNonConcurrentBase ESSourceProductResolverNonConcurrentBase.h "FWCore/Framework/interface/ESSourceProductResolverNonConcurrentBase.h" +/**\class edm::eventsetup::ESSourceProductResolverNonConcurrentBase - Description: Base class for DataProxies for ESSources that require synchronization + Description: Base class for ESProductResolvers for ESSources that require synchronization Usage: - The ESSourceProductResolverNonConcurrentBase uses a SerialTaskQueue to serialize all DataProxies for the ESSource and a + The ESSourceProductResolverNonConcurrentBase uses a SerialTaskQueue to serialize all ESProductResolvers for the ESSource and a std::mutex to protect from concurrent calls to a ESProductResolver and the ESSource itself. Such concurrent calls can happen if concurrent LuminosityBlocks are being used. diff --git a/FWCore/Framework/interface/EventSetupProvider.h b/FWCore/Framework/interface/EventSetupProvider.h index 31a902d546f2b..96673e672500d 100644 --- a/FWCore/Framework/interface/EventSetupProvider.h +++ b/FWCore/Framework/interface/EventSetupProvider.h @@ -1,6 +1,6 @@ +// -*- C++ -*- #ifndef FWCore_Framework_EventSetupProvider_h #define FWCore_Framework_EventSetupProvider_h -// -*- C++ -*- // // Package: Framework // Class: EventSetupProvider @@ -83,7 +83,7 @@ namespace edm { void finishConfiguration(NumberOfConcurrentIOVs const&, bool& hasNonconcurrentFinder); - ///Used when we need to force a Record to reset all its proxies + ///Used when we need to force a Record to reset all its resolvers void resetRecordPlusDependentRecords(EventSetupRecordKey const&); ///Used when testing that all code properly updates on IOV changes of all Records diff --git a/FWCore/Framework/interface/EventSetupRecord.h b/FWCore/Framework/interface/EventSetupRecord.h index 4d65b917f0fb7..ced7bb3b8ca7a 100644 --- a/FWCore/Framework/interface/EventSetupRecord.h +++ b/FWCore/Framework/interface/EventSetupRecord.h @@ -16,7 +16,7 @@ use to get data associated with a record. This class holds a pointer to an EventSetupRecordImpl class, which - is the class used to get the DataProxies associated with a given Record. + is the class used to get the ESProductResolvers associated with a given Record. It also has a pointer to the EventSetupImpl which is used to lookup dependent records in DependentRecordImplementation. diff --git a/FWCore/Framework/interface/EventSetupRecordImpl.h b/FWCore/Framework/interface/EventSetupRecordImpl.h index 0ecef64a0751a..e48ca71ec8554 100644 --- a/FWCore/Framework/interface/EventSetupRecordImpl.h +++ b/FWCore/Framework/interface/EventSetupRecordImpl.h @@ -10,17 +10,17 @@ Description: Base class for all Records in an EventSetup. Holds data with the same lifetime. Usage: -This class contains the Proxies that make up a given Record. It +This class contains the Resolvers that make up a given Record. It is designed to be reused time after time, rather than it being destroyed and a new one created every time a new Record is -required. Proxies can only be added by the EventSetupRecordProvider class which +required. Resolvers can only be added by the EventSetupRecordProvider class which uses the 'add' function to do this. -When the set of Proxies for a Records changes, i.e. a +When the set of Resolvers for a Records changes, i.e. a ESProductResolverProvider is added of removed from the system, then the -Proxies in a Record need to be changed as appropriate. +Resolvers in a Record need to be changed as appropriate. In this design it was decided the easiest way to achieve this was -to erase all Proxies in a Record. +to erase all Resolvers in a Record. It is important for the management of the Records that each Record know the ValidityInterval that represents the time over which its data is valid. @@ -120,7 +120,7 @@ namespace edm { // The following member functions should only be used by EventSetupRecordProvider bool add(DataKey const& iKey, ESProductResolver* iResolver); - void clearProxies(); + void clearResolvers(); ///Set the cache identifier and validity interval when starting a new IOV ///In addition, also notify the ESProductResolver's a new IOV is starting. @@ -147,8 +147,8 @@ namespace edm { ComponentDescription const*, DataKey const&) const; - void invalidateProxies(); - void resetIfTransientInProxies(); + void invalidateResolvers(); + void resetIfTransientInResolvers(); private: void const* getFromResolverAfterPrefetch(ESResolverIndex iResolverIndex, @@ -164,7 +164,7 @@ namespace edm { std::shared_ptr& whyFailedFactory) const { DataKey const* dataKey = nullptr; assert(iResolverIndex.value() > -1 and - iResolverIndex.value() < static_cast(keysForProxies_.size())); + iResolverIndex.value() < static_cast(keysForResolvers_.size())); void const* pValue = this->getFromResolverAfterPrefetch(iResolverIndex, iTransientAccessOnly, oDesc, dataKey); iData = reinterpret_cast(pValue); } @@ -181,8 +181,8 @@ namespace edm { CMS_THREAD_SAFE mutable ValidityInterval validity_; EventSetupRecordKey key_; - std::vector keysForProxies_; - std::vector> proxies_; + std::vector keysForResolvers_; + std::vector> resolvers_; ActivityRegistry const* activityRegistry_; unsigned long long cacheIdentifier_; unsigned int iovIndex_; diff --git a/FWCore/Framework/interface/EventSetupRecordProvider.h b/FWCore/Framework/interface/EventSetupRecordProvider.h index e95ad5e703aa1..a1891dede5f6f 100644 --- a/FWCore/Framework/interface/EventSetupRecordProvider.h +++ b/FWCore/Framework/interface/EventSetupRecordProvider.h @@ -1,6 +1,6 @@ +// -*- C++ -*- #ifndef FWCore_Framework_EventSetupRecordProvider_h #define FWCore_Framework_EventSetupRecordProvider_h -// -*- C++ -*- // // Package: Framework // Class : EventSetupRecordProvider @@ -140,8 +140,8 @@ namespace edm { all providers have been added. An empty map is acceptable. */ void usePreferred(DataToPreferredProviderMap const&); - ///This will clear the cache's of all the Proxies so that next time they are called they will run - void resetProxies(); + ///This will clear the cache's of all the Resolvers so that next time they are called they will run + void resetResolvers(); std::shared_ptr finder() const { return get_underlying_safe(finder_); } std::shared_ptr& finder() { return get_underlying_safe(finder_); } @@ -158,11 +158,11 @@ namespace edm { IntervalStatus intervalStatus() const { return intervalStatus_; } protected: - void addProxiesToRecordHelper(edm::propagate_const>& dpp, - DataToPreferredProviderMap const& mp) { - addProxiesToRecord(get_underlying_safe(dpp), mp); + void addResolversToRecordHelper(edm::propagate_const>& dpp, + DataToPreferredProviderMap const& mp) { + addResolversToRecord(get_underlying_safe(dpp), mp); } - void addProxiesToRecord(std::shared_ptr, DataToPreferredProviderMap const&); + void addResolversToRecord(std::shared_ptr, DataToPreferredProviderMap const&); std::shared_ptr swapFinder(std::shared_ptr iNew) { std::swap(iNew, finder()); diff --git a/FWCore/Framework/src/ESProductResolverProvider.cc b/FWCore/Framework/src/ESProductResolverProvider.cc index adf4fba4b34da..42412e0285861 100644 --- a/FWCore/Framework/src/ESProductResolverProvider.cc +++ b/FWCore/Framework/src/ESProductResolverProvider.cc @@ -47,19 +47,19 @@ namespace edm { } void ESProductResolverProvider::KeyedResolvers::insert( - std::vector>>&& proxies, + std::vector>>&& resolvers, std::string const& appendToDataLabel) { PerRecordInfo& perRecordInfo = productResolverContainer_->perRecordInfos_[recordIndex_]; if (perRecordInfo.indexToDataKeys_ == kInvalidIndex) { - perRecordInfo.nDataKeys_ = proxies.size(); + perRecordInfo.nDataKeys_ = resolvers.size(); perRecordInfo.indexToDataKeys_ = productResolverContainer_->dataKeys_.size(); - for (auto const& it : proxies) { + for (auto const& it : resolvers) { productResolverContainer_->dataKeys_.push_back(it.first); } } else { - assert(perRecordInfo.nDataKeys_ == proxies.size()); + assert(perRecordInfo.nDataKeys_ == resolvers.size()); unsigned index = 0; - for (auto const& it : proxies) { + for (auto const& it : resolvers) { if (appendToDataLabel.empty()) { assert(it.first == productResolverContainer_->dataKeys_[perRecordInfo.indexToDataKeys_ + index]); } else { @@ -76,7 +76,7 @@ namespace edm { } assert(unInitialized()); productResolversIndex_ = productResolverContainer_->productResolvers_.size(); - for (auto const& it : proxies) { + for (auto const& it : resolvers) { productResolverContainer_->productResolvers_.emplace_back(it.second); } } diff --git a/FWCore/Framework/src/EventSetupProvider.cc b/FWCore/Framework/src/EventSetupProvider.cc index c4b45655a4c67..6b3165f183eef 100644 --- a/FWCore/Framework/src/EventSetupProvider.cc +++ b/FWCore/Framework/src/EventSetupProvider.cc @@ -264,7 +264,7 @@ namespace edm { finders_.reset(); //Now handle providers since sources can also be finders and the sources can delay registering - // their Records and therefore could delay setting up their Proxies + // their Records and therefore could delay setting up their Resolvers psetIDToRecordKey_->clear(); for (auto& productResolverProvider : *dataProviders_) { ParameterSetIDHolder psetID(productResolverProvider->description().pid_); @@ -383,16 +383,16 @@ namespace edm { dependents.erase(std::unique(dependents.begin(), dependents.end()), dependents.end()); - recProvider->resetProxies(); + recProvider->resetResolvers(); for (auto& d : dependents) { - d->resetProxies(); + d->resetResolvers(); } } void EventSetupProvider::forceCacheClear() { for (auto& recProvider : recordProviders_) { if (recProvider) { - recProvider->resetProxies(); + recProvider->resetResolvers(); } } } diff --git a/FWCore/Framework/src/EventSetupRecordImpl.cc b/FWCore/Framework/src/EventSetupRecordImpl.cc index 66fe1d5dba25b..e2b37663e70c9 100644 --- a/FWCore/Framework/src/EventSetupRecordImpl.cc +++ b/FWCore/Framework/src/EventSetupRecordImpl.cc @@ -43,8 +43,8 @@ namespace edm { EventSetupRecordImpl::EventSetupRecordImpl(EventSetupRecordImpl&& source) : validity_{source.validity_}, key_{source.key_}, - keysForProxies_{std::move(source.keysForProxies_)}, - proxies_(std::move(source.proxies_)), + keysForResolvers_{std::move(source.keysForResolvers_)}, + resolvers_(std::move(source.resolvers_)), activityRegistry_{source.activityRegistry_}, cacheIdentifier_{source.cacheIdentifier_}, iovIndex_{source.iovIndex_}, @@ -54,8 +54,8 @@ namespace edm { EventSetupRecordImpl& EventSetupRecordImpl::operator=(EventSetupRecordImpl&& rhs) { validity_ = rhs.validity_; key_ = rhs.key_; - keysForProxies_ = std::move(rhs.keysForProxies_); - proxies_ = std::move(rhs.proxies_); + keysForResolvers_ = std::move(rhs.keysForResolvers_); + resolvers_ = std::move(rhs.resolvers_); activityRegistry_ = rhs.activityRegistry_; cacheIdentifier_ = rhs.cacheIdentifier_; iovIndex_ = rhs.iovIndex_; @@ -80,7 +80,7 @@ namespace edm { cacheIdentifier_ = iCacheIdentifier; validity_ = iValidityInterval; if (hasFinder) { - for (auto& productResolver : proxies_) { + for (auto& productResolver : resolvers_) { productResolver->initializeForNewIOV(); } } @@ -97,8 +97,8 @@ namespace edm { void EventSetupRecordImpl::getESProducers(std::vector& esproducers) const { esproducers.clear(); - esproducers.reserve(proxies_.size()); - for (auto const& iData : proxies_) { + esproducers.reserve(resolvers_.size()); + for (auto const& iData : resolvers_) { ComponentDescription const* componentDescription = iData->providerDescription(); if (!componentDescription->isLooper_ && !componentDescription->isSource_) { esproducers.push_back(componentDescription); @@ -108,8 +108,8 @@ namespace edm { std::vector EventSetupRecordImpl::componentsForRegisteredDataKeys() const { std::vector ret; - ret.reserve(proxies_.size()); - for (auto const& resolver : proxies_) { + ret.reserve(resolvers_.size()); + for (auto const& resolver : resolvers_) { ret.push_back(resolver->providerDescription()); } return ret; @@ -130,8 +130,9 @@ namespace edm { assert(resolver->providerDescription()); assert(iResolver->providerDescription()); if (iResolver->providerDescription()->isLooper_) { - proxies_[std::distance(keysForProxies_.begin(), - std::lower_bound(keysForProxies_.begin(), keysForProxies_.end(), iKey))] = iResolver; + resolvers_[std::distance(keysForResolvers_.begin(), + std::lower_bound(keysForResolvers_.begin(), keysForResolvers_.end(), iKey))] = + iResolver; return true; } @@ -150,33 +151,34 @@ namespace edm { << "\n or find a way of configuring one of them so it does not deliver this data" << "\n or use an es_prefer statement in the configuration to choose one."; } else if (resolver->providerDescription()->isSource_) { - proxies_[std::distance(keysForProxies_.begin(), - std::lower_bound(keysForProxies_.begin(), keysForProxies_.end(), iKey))] = iResolver; + resolvers_[std::distance(keysForResolvers_.begin(), + std::lower_bound(keysForResolvers_.begin(), keysForResolvers_.end(), iKey))] = + iResolver; } else { return false; } } else { - auto lb = std::lower_bound(keysForProxies_.begin(), keysForProxies_.end(), iKey); - auto index = std::distance(keysForProxies_.begin(), lb); - keysForProxies_.insert(lb, iKey); - proxies_.insert(proxies_.begin() + index, iResolver); + auto lb = std::lower_bound(keysForResolvers_.begin(), keysForResolvers_.end(), iKey); + auto index = std::distance(keysForResolvers_.begin(), lb); + keysForResolvers_.insert(lb, iKey); + resolvers_.insert(resolvers_.begin() + index, iResolver); } return true; } - void EventSetupRecordImpl::clearProxies() { - keysForProxies_.clear(); - proxies_.clear(); + void EventSetupRecordImpl::clearResolvers() { + keysForResolvers_.clear(); + resolvers_.clear(); } - void EventSetupRecordImpl::invalidateProxies() { - for (auto& productResolver : proxies_) { + void EventSetupRecordImpl::invalidateResolvers() { + for (auto& productResolver : resolvers_) { productResolver->invalidate(); } } - void EventSetupRecordImpl::resetIfTransientInProxies() { - for (auto& productResolver : proxies_) { + void EventSetupRecordImpl::resetIfTransientInResolvers() { + for (auto& productResolver : resolvers_) { productResolver->resetIfTransient(); } } @@ -185,11 +187,11 @@ namespace edm { bool iTransientAccessOnly, ComponentDescription const*& iDesc, DataKey const*& oGottenKey) const { - const ESProductResolver* resolver = proxies_[iResolverIndex.value()]; + const ESProductResolver* resolver = resolvers_[iResolverIndex.value()]; assert(nullptr != resolver); iDesc = resolver->providerDescription(); - auto const& key = keysForProxies_[iResolverIndex.value()]; + auto const& key = keysForResolvers_[iResolverIndex.value()]; oGottenKey = &key; void const* hold = nullptr; @@ -203,11 +205,11 @@ namespace edm { } const ESProductResolver* EventSetupRecordImpl::find(const DataKey& iKey) const { - auto lb = std::lower_bound(keysForProxies_.begin(), keysForProxies_.end(), iKey); - if ((lb == keysForProxies_.end()) or (*lb != iKey)) { + auto lb = std::lower_bound(keysForResolvers_.begin(), keysForResolvers_.end(), iKey); + if ((lb == keysForResolvers_.end()) or (*lb != iKey)) { return nullptr; } - return proxies_[std::distance(keysForProxies_.begin(), lb)].get(); + return resolvers_[std::distance(keysForResolvers_.begin(), lb)].get(); } void EventSetupRecordImpl::prefetchAsync(WaitingTaskHolder iTask, @@ -220,9 +222,9 @@ namespace edm { return; } - const ESProductResolver* resolver = proxies_[iResolverIndex.value()]; + const ESProductResolver* resolver = resolvers_[iResolverIndex.value()]; if (nullptr != resolver) { - auto const& key = keysForProxies_[iResolverIndex.value()]; + auto const& key = keysForResolvers_[iResolverIndex.value()]; resolver->prefetchAsync(iTask, *this, key, iEventSetupImpl, iToken, iParent); } } @@ -244,7 +246,7 @@ namespace edm { } void EventSetupRecordImpl::fillRegisteredDataKeys(std::vector& oToFill) const { - oToFill = keysForProxies_; + oToFill = keysForResolvers_; } void EventSetupRecordImpl::addTraceInfoToCmsException(cms::Exception& iException, diff --git a/FWCore/Framework/src/EventSetupRecordProvider.cc b/FWCore/Framework/src/EventSetupRecordProvider.cc index 77121dab1aae0..5daa14824bcb8 100644 --- a/FWCore/Framework/src/EventSetupRecordProvider.cc +++ b/FWCore/Framework/src/EventSetupRecordProvider.cc @@ -98,7 +98,7 @@ namespace edm { } void EventSetupRecordProvider::usePreferred(const DataToPreferredProviderMap& iMap) { using std::placeholders::_1; - for_all(providers_, std::bind(&EventSetupRecordProvider::addProxiesToRecordHelper, this, _1, iMap)); + for_all(providers_, std::bind(&EventSetupRecordProvider::addResolversToRecordHelper, this, _1, iMap)); if (1 < multipleFinders_->size()) { std::shared_ptr intFinder = make_shared_noexcept_false(key_); @@ -113,8 +113,9 @@ namespace edm { multipleFinders_.reset(nullptr); } - void EventSetupRecordProvider::addProxiesToRecord(std::shared_ptr iProvider, - const EventSetupRecordProvider::DataToPreferredProviderMap& iMap) { + void EventSetupRecordProvider::addResolversToRecord( + std::shared_ptr iProvider, + const EventSetupRecordProvider::DataToPreferredProviderMap& iMap) { typedef ESProductResolverProvider::KeyedResolvers ResolverList; typedef EventSetupRecordProvider::DataToPreferredProviderMap PreferredMap; @@ -152,7 +153,7 @@ namespace edm { } } - void EventSetupRecordProvider::endIOV(unsigned int iovIndex) { recordImpls_[iovIndex].invalidateProxies(); } + void EventSetupRecordProvider::endIOV(unsigned int iovIndex) { recordImpls_[iovIndex].invalidateResolvers(); } void EventSetupRecordProvider::initializeForNewSyncValue() { intervalStatus_ = IntervalStatus::NotInitializedForSyncValue; @@ -212,11 +213,11 @@ namespace edm { return intervalStatus_ != IntervalStatus::Invalid; } - void EventSetupRecordProvider::resetProxies() { + void EventSetupRecordProvider::resetResolvers() { // Clear out all the ESProductResolver's for (auto& recordImplIter : recordImpls_) { - recordImplIter.invalidateProxies(); - recordImplIter.resetIfTransientInProxies(); + recordImplIter.invalidateResolvers(); + recordImplIter.resetIfTransientInResolvers(); } // Force a new IOV to start with a new cacheIdentifier // on the next eventSetupForInstance call. @@ -245,10 +246,10 @@ namespace edm { void EventSetupRecordProvider::resetRecordToResolverPointers(DataToPreferredProviderMap const& iMap) { for (auto& recordImplIter : recordImpls_) { - recordImplIter.clearProxies(); + recordImplIter.clearResolvers(); } using std::placeholders::_1; - for_all(providers_, std::bind(&EventSetupRecordProvider::addProxiesToRecordHelper, this, _1, iMap)); + for_all(providers_, std::bind(&EventSetupRecordProvider::addResolversToRecordHelper, this, _1, iMap)); } std::set EventSetupRecordProvider::dependentRecords() const { return dependencies(key()); } diff --git a/FWCore/Framework/test/dependentrecord_t.cppunit.cc b/FWCore/Framework/test/dependentrecord_t.cppunit.cc index df0e2accdb214..4c28d038b5528 100644 --- a/FWCore/Framework/test/dependentrecord_t.cppunit.cc +++ b/FWCore/Framework/test/dependentrecord_t.cppunit.cc @@ -761,15 +761,15 @@ namespace { void prefetch(edm::EventSetupImpl const& iImpl) const { auto const& recs = this->esGetTokenRecordIndicesVector(edm::Transition::Event); - auto const& proxies = this->esGetTokenIndicesVector(edm::Transition::Event); - for (size_t i = 0; i != proxies.size(); ++i) { + auto const& resolvers = this->esGetTokenIndicesVector(edm::Transition::Event); + for (size_t i = 0; i != resolvers.size(); ++i) { auto rec = iImpl.findImpl(recs[i]); if (rec) { oneapi::tbb::task_group group; edm::FinalWaitingTask waitTask{group}; edm::ServiceToken token; rec->prefetchAsync( - edm::WaitingTaskHolder(group, &waitTask), proxies[i], &iImpl, token, edm::ESParentContext{}); + edm::WaitingTaskHolder(group, &waitTask), resolvers[i], &iImpl, token, edm::ESParentContext{}); waitTask.wait(); } } @@ -785,15 +785,15 @@ namespace { void prefetch(edm::EventSetupImpl const& iImpl) const { auto const& recs = this->esGetTokenRecordIndicesVector(edm::Transition::Event); - auto const& proxies = this->esGetTokenIndicesVector(edm::Transition::Event); - for (size_t i = 0; i != proxies.size(); ++i) { + auto const& resolvers = this->esGetTokenIndicesVector(edm::Transition::Event); + for (size_t i = 0; i != resolvers.size(); ++i) { auto rec = iImpl.findImpl(recs[i]); if (rec) { oneapi::tbb::task_group group; edm::FinalWaitingTask waitTask{group}; edm::ServiceToken token; rec->prefetchAsync( - edm::WaitingTaskHolder(group, &waitTask), proxies[i], &iImpl, token, edm::ESParentContext{}); + edm::WaitingTaskHolder(group, &waitTask), resolvers[i], &iImpl, token, edm::ESParentContext{}); waitTask.wait(); } } diff --git a/FWCore/Framework/test/esproducer_t.cppunit.cc b/FWCore/Framework/test/esproducer_t.cppunit.cc index 53e19105b7a62..69207d40666f2 100644 --- a/FWCore/Framework/test/esproducer_t.cppunit.cc +++ b/FWCore/Framework/test/esproducer_t.cppunit.cc @@ -53,14 +53,17 @@ namespace { struct DummyDataConsumerBase : public edm::EDConsumerBase { void prefetch(edm::EventSetupImpl const& iImpl) const { auto const& recs = this->esGetTokenRecordIndicesVector(edm::Transition::Event); - auto const& proxies = this->esGetTokenIndicesVector(edm::Transition::Event); - for (size_t i = 0; i != proxies.size(); ++i) { + auto const& resolvers = this->esGetTokenIndicesVector(edm::Transition::Event); + for (size_t i = 0; i != resolvers.size(); ++i) { auto rec = iImpl.findImpl(recs[i]); if (rec) { oneapi::tbb::task_group group; edm::FinalWaitingTask waitTask{group}; - rec->prefetchAsync( - edm::WaitingTaskHolder(group, &waitTask), proxies[i], &iImpl, edm::ServiceToken{}, edm::ESParentContext{}); + rec->prefetchAsync(edm::WaitingTaskHolder(group, &waitTask), + resolvers[i], + &iImpl, + edm::ServiceToken{}, + edm::ESParentContext{}); waitTask.wait(); } } diff --git a/FWCore/Framework/test/eventsetup_t.cppunit.cc b/FWCore/Framework/test/eventsetup_t.cppunit.cc index 0de30047ddd9c..a87f0b14d0bbc 100644 --- a/FWCore/Framework/test/eventsetup_t.cppunit.cc +++ b/FWCore/Framework/test/eventsetup_t.cppunit.cc @@ -100,7 +100,7 @@ class testEventsetup : public CppUnit::TestFixture { CPPUNIT_TEST(introspectionTest); CPPUNIT_TEST(iovExtensionTest); - CPPUNIT_TEST(resetProxiesTest); + CPPUNIT_TEST(resetResolversTest); CPPUNIT_TEST_SUITE_END(); @@ -132,7 +132,7 @@ class testEventsetup : public CppUnit::TestFixture { void introspectionTest(); void iovExtensionTest(); - void resetProxiesTest(); + void resetResolversTest(); private: edm::propagate_const> m_scheduler; @@ -422,14 +422,14 @@ namespace { void prefetch(edm::EventSetupImpl const& iImpl) const { auto const& recs = this->esGetTokenRecordIndicesVector(edm::Transition::Event); - auto const& proxies = this->esGetTokenIndicesVector(edm::Transition::Event); - for (size_t i = 0; i != proxies.size(); ++i) { + auto const& resolvers = this->esGetTokenIndicesVector(edm::Transition::Event); + for (size_t i = 0; i != resolvers.size(); ++i) { auto rec = iImpl.findImpl(recs[i]); if (rec) { oneapi::tbb::task_group group; edm::FinalWaitingTask waitTask{group}; rec->prefetchAsync( - WaitingTaskHolder(group, &waitTask), proxies[i], &iImpl, edm::ServiceToken{}, edm::ESParentContext{}); + WaitingTaskHolder(group, &waitTask), resolvers[i], &iImpl, edm::ServiceToken{}, edm::ESParentContext{}); waitTask.wait(); } } @@ -1165,7 +1165,7 @@ void testEventsetup::preferTest() { EventSetupProvider::PreferredProviderInfo preferInfo; EventSetupProvider::RecordToDataMap recordToData; - //default means use all proxies + //default means use all resolvers preferInfo[ComponentDescription("DummyESProductResolverProvider", "", ComponentDescription::unknownID(), false)] = recordToData; provider.setPreferredProviderInfo(preferInfo); @@ -1201,7 +1201,7 @@ void testEventsetup::preferTest() { EventSetupProvider::PreferredProviderInfo preferInfo; EventSetupProvider::RecordToDataMap recordToData; - //default means use all proxies + //default means use all resolvers preferInfo[ComponentDescription("DummyESProductResolverProvider", "", ComponentDescription::unknownID(), false)] = recordToData; provider.setPreferredProviderInfo(preferInfo); @@ -1370,7 +1370,7 @@ void testEventsetup::iovExtensionTest() { } } -void testEventsetup::resetProxiesTest() { +void testEventsetup::resetResolversTest() { SynchronousEventSetupsController controller; edm::ParameterSet pset = createDummyPset(); EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry); diff --git a/FWCore/Framework/test/eventsetuprecord_t.cppunit.cc b/FWCore/Framework/test/eventsetuprecord_t.cppunit.cc index 8b058afe4d7a0..21cad52dba253 100644 --- a/FWCore/Framework/test/eventsetuprecord_t.cppunit.cc +++ b/FWCore/Framework/test/eventsetuprecord_t.cppunit.cc @@ -189,12 +189,12 @@ namespace { explicit DummyDataConsumer(ESInputTag const& iTag) : m_token{esConsumes(iTag)} {} void prefetch(eventsetup::EventSetupRecordImpl const& iRec) const { - auto const& proxies = this->esGetTokenIndicesVector(edm::Transition::Event); - for (size_t i = 0; i != proxies.size(); ++i) { + auto const& resolvers = this->esGetTokenIndicesVector(edm::Transition::Event); + for (size_t i = 0; i != resolvers.size(); ++i) { oneapi::tbb::task_group group; edm::FinalWaitingTask waitTask{group}; edm::ServiceToken token; - iRec.prefetchAsync(WaitingTaskHolder(group, &waitTask), proxies[i], nullptr, token, edm::ESParentContext{}); + iRec.prefetchAsync(WaitingTaskHolder(group, &waitTask), resolvers[i], nullptr, token, edm::ESParentContext{}); waitTask.wait(); } } @@ -207,12 +207,12 @@ namespace { : m_token{esConsumes<>(eventsetup::EventSetupRecordKey::makeKey(), iKey)} {} void prefetch(eventsetup::EventSetupRecordImpl const& iRec) const { - auto const& proxies = this->esGetTokenIndicesVector(edm::Transition::Event); - for (size_t i = 0; i != proxies.size(); ++i) { + auto const& resolvers = this->esGetTokenIndicesVector(edm::Transition::Event); + for (size_t i = 0; i != resolvers.size(); ++i) { oneapi::tbb::task_group group; edm::FinalWaitingTask waitTask{group}; edm::ServiceToken token; - iRec.prefetchAsync(WaitingTaskHolder(group, &waitTask), proxies[i], nullptr, token, edm::ESParentContext{}); + iRec.prefetchAsync(WaitingTaskHolder(group, &waitTask), resolvers[i], nullptr, token, edm::ESParentContext{}); waitTask.wait(); } } @@ -229,7 +229,7 @@ namespace { edm::EventSetupImpl& eventSetupImpl_; CONSUMER& consumer; //we need the DataKeys to stick around since references are being kept to them - std::vector> proxies; + std::vector> resolvers; // same for ESParentContext ESParentContext pc_; @@ -237,12 +237,12 @@ namespace { EventSetupRecordKey const& iKey, EventSetupImpl& iEventSetup, ActivityRegistry* iRegistry, - std::vector> iProxies) + std::vector> iResolvers) : dummyRecordImpl(iKey, iRegistry), eventSetupImpl_(iEventSetup), consumer(iConsumer), - proxies(std::move(iProxies)) { - for (auto const& d : proxies) { + resolvers(std::move(iResolvers)) { + for (auto const& d : resolvers) { dummyRecordImpl.add(d.first, d.second); } @@ -658,7 +658,7 @@ void testEventsetupRecord::introspectionTest() { CPPUNIT_ASSERT(referencedComponents.size() == 4); CPPUNIT_ASSERT(find(referencedDataKeys, referencedComponents, workingDataKey4) == &cd4); - dummyRecordImpl.clearProxies(); + dummyRecordImpl.clearResolvers(); dummyRecord.fillRegisteredDataKeys(keys); CPPUNIT_ASSERT(0 == keys.size()); } @@ -716,7 +716,7 @@ void testEventsetupRecord::resolverResetTest() { wdProv->createKeyedResolvers(DummyRecord::keyForClass(), 1); dummyProvider->add(wdProv); - //this causes the proxies to actually be placed in the Record + //this causes the resolvers to actually be placed in the Record edm::eventsetup::EventSetupRecordProvider::DataToPreferredProviderMap pref; dummyProvider->usePreferred(pref); @@ -733,7 +733,7 @@ void testEventsetupRecord::resolverResetTest() { CPPUNIT_ASSERT(!workingResolver->invalidateCalled()); CPPUNIT_ASSERT(!workingResolver->invalidateTransientCalled()); - dummyProvider->resetProxies(); + dummyProvider->resetResolvers(); CPPUNIT_ASSERT(workingResolver->invalidateCalled()); CPPUNIT_ASSERT(workingResolver->invalidateTransientCalled()); consumer.prefetch(sr.dummyRecordImpl); @@ -771,7 +771,7 @@ void testEventsetupRecord::transientTest() { wdProv->createKeyedResolvers(DummyRecord::keyForClass(), 1); dummyProvider->add(wdProv); - //this causes the proxies to actually be placed in the Record + //this causes the resolvers to actually be placed in the Record edm::eventsetup::EventSetupRecordProvider::DataToPreferredProviderMap pref; dummyProvider->usePreferred(pref); @@ -784,7 +784,7 @@ void testEventsetupRecord::transientTest() { CPPUNIT_ASSERT(workingResolver->invalidateCalled() == false); CPPUNIT_ASSERT(workingResolver->invalidateTransientCalled() == false); - nonConstDummyRecordImpl.resetIfTransientInProxies(); + nonConstDummyRecordImpl.resetIfTransientInResolvers(); CPPUNIT_ASSERT(workingResolver->invalidateCalled()); CPPUNIT_ASSERT(workingResolver->invalidateTransientCalled()); @@ -797,7 +797,7 @@ void testEventsetupRecord::transientTest() { hDummy = dummyRecord.getHandleImpl(token); CPPUNIT_ASSERT(&myDummy2 == &(*hDummy)); - nonConstDummyRecordImpl.resetIfTransientInProxies(); + nonConstDummyRecordImpl.resetIfTransientInResolvers(); CPPUNIT_ASSERT(workingResolver->invalidateCalled() == false); CPPUNIT_ASSERT(workingResolver->invalidateTransientCalled() == false); @@ -806,13 +806,13 @@ void testEventsetupRecord::transientTest() { hDummy = dummyRecord.getHandleImpl(token); hTDummy = dummyRecord.getHandleImpl(token); - nonConstDummyRecordImpl.resetIfTransientInProxies(); + nonConstDummyRecordImpl.resetIfTransientInResolvers(); CPPUNIT_ASSERT(workingResolver->invalidateCalled() == false); CPPUNIT_ASSERT(workingResolver->invalidateTransientCalled() == false); //Ask for a transient then a non transient to be sure we don't have an ordering problem { - dummyProvider->resetProxies(); + dummyProvider->resetResolvers(); Dummy myDummy3; workingResolver->set(&myDummy3); @@ -822,7 +822,7 @@ void testEventsetupRecord::transientTest() { CPPUNIT_ASSERT(&myDummy3 == &(*hDummy)); CPPUNIT_ASSERT(&myDummy3 == &(*hTDummy)); - nonConstDummyRecordImpl.resetIfTransientInProxies(); + nonConstDummyRecordImpl.resetIfTransientInResolvers(); CPPUNIT_ASSERT(workingResolver->invalidateCalled() == false); CPPUNIT_ASSERT(workingResolver->invalidateTransientCalled() == false); } diff --git a/FWCore/Framework/test/fullchain_t.cppunit.cc b/FWCore/Framework/test/fullchain_t.cppunit.cc index f4275e0cd22bf..87f5e0e2ec80c 100644 --- a/FWCore/Framework/test/fullchain_t.cppunit.cc +++ b/FWCore/Framework/test/fullchain_t.cppunit.cc @@ -53,14 +53,14 @@ namespace { void prefetch(edm::EventSetupImpl const& iImpl) const { auto const& recs = this->esGetTokenRecordIndicesVector(edm::Transition::Event); - auto const& proxies = this->esGetTokenIndicesVector(edm::Transition::Event); - for (size_t i = 0; i != proxies.size(); ++i) { + auto const& resolvers = this->esGetTokenIndicesVector(edm::Transition::Event); + for (size_t i = 0; i != resolvers.size(); ++i) { auto rec = iImpl.findImpl(recs[i]); if (rec) { oneapi::tbb::task_group group; edm::FinalWaitingTask waitTask{group}; rec->prefetchAsync( - WaitingTaskHolder(group, &waitTask), proxies[i], &iImpl, edm::ServiceToken{}, edm::ESParentContext{}); + WaitingTaskHolder(group, &waitTask), resolvers[i], &iImpl, edm::ServiceToken{}, edm::ESParentContext{}); waitTask.wait(); } } diff --git a/FWCore/Integration/plugins/ESTestProducers.cc b/FWCore/Integration/plugins/ESTestProducers.cc index cdb846d673199..8b9c18ac4e276 100644 --- a/FWCore/Integration/plugins/ESTestProducers.cc +++ b/FWCore/Integration/plugins/ESTestProducers.cc @@ -316,7 +316,7 @@ namespace edmtest { private: KeyedResolversVector registerResolvers(const edm::eventsetup::EventSetupRecordKey&, unsigned int iovIndex) override; - std::vector> proxies_; + std::vector> resolvers_; std::vector expectedCacheIds_; }; @@ -335,11 +335,11 @@ namespace edmtest { edm::eventsetup::ESProductResolverProvider::KeyedResolversVector ESTestESProductResolverProviderJ::registerResolvers( const edm::eventsetup::EventSetupRecordKey& iRecord, unsigned int iovIndex) { KeyedResolversVector keyedResolversVector; - while (iovIndex >= proxies_.size()) { - proxies_.push_back(std::make_shared(&expectedCacheIds_)); + while (iovIndex >= resolvers_.size()) { + resolvers_.push_back(std::make_shared(&expectedCacheIds_)); } edm::eventsetup::DataKey dataKey(edm::eventsetup::DataKey::makeTypeTag(), ""); - keyedResolversVector.emplace_back(dataKey, proxies_[iovIndex]); + keyedResolversVector.emplace_back(dataKey, resolvers_[iovIndex]); return keyedResolversVector; } } // namespace edmtest diff --git a/FWCore/TestProcessor/interface/EventSetupTestHelper.h b/FWCore/TestProcessor/interface/EventSetupTestHelper.h index c4b50e1443dea..6b7b32ec8ed46 100644 --- a/FWCore/TestProcessor/interface/EventSetupTestHelper.h +++ b/FWCore/TestProcessor/interface/EventSetupTestHelper.h @@ -1,11 +1,11 @@ +// -*- C++ -*- #ifndef FWCore_TestProcessor_EventSetupTestHelper_h #define FWCore_TestProcessor_EventSetupTestHelper_h -// -*- C++ -*- // // Package: FWCore/TestProcessor // Class : EventSetupTestHelper // -/**\class EventSetupTestHelper EventSetupTestHelper.h "EventSetupTestHelper.h" +/**\class edm::test::EventSetupTestHelper Description: [one line class summary] @@ -39,7 +39,7 @@ namespace edm { std::shared_ptr getResolver(unsigned int index); - void resetAllProxies(); + void resetAllResolvers(); protected: void setIntervalFor(const eventsetup::EventSetupRecordKey&, const IOVSyncValue&, ValidityInterval&) final; @@ -48,7 +48,7 @@ namespace edm { private: // ---------- member data -------------------------------- - std::vector proxies_; + std::vector resolvers_; }; } // namespace test } // namespace edm diff --git a/FWCore/TestProcessor/src/EventSetupTestHelper.cc b/FWCore/TestProcessor/src/EventSetupTestHelper.cc index 6b8e04366f447..640f4e464b47b 100644 --- a/FWCore/TestProcessor/src/EventSetupTestHelper.cc +++ b/FWCore/TestProcessor/src/EventSetupTestHelper.cc @@ -19,10 +19,11 @@ namespace edm { namespace test { - EventSetupTestHelper::EventSetupTestHelper(std::vector iProxies) : proxies_{std::move(iProxies)} { + EventSetupTestHelper::EventSetupTestHelper(std::vector iResolvers) + : resolvers_{std::move(iResolvers)} { //Deal with duplicates std::set records; - for (auto const& p : proxies_) { + for (auto const& p : resolvers_) { records.insert(p.recordKey_); } for (auto const& k : records) { @@ -34,18 +35,18 @@ namespace edm { void EventSetupTestHelper::setIntervalFor(const eventsetup::EventSetupRecordKey&, const IOVSyncValue& iSync, ValidityInterval& oIOV) { - // Note that we manually invalidate the proxies at the end of every call + // Note that we manually invalidate the resolvers at the end of every call // to test. And the beginning of the call to test is the only opportunity // to reset this data, so we are not relying on the EventSetup system - // to manage invalidating the proxies in EventSetupTestHelper. The only + // to manage invalidating the resolvers in EventSetupTestHelper. The only // reasonable thing to do is return an interval for all time so the EventSetup - // system does not invalidate these proxies when it shouldn't. There are two + // system does not invalidate these resolvers when it shouldn't. There are two // weaknesses to this: // - // 1. If for the same record type there are DataProxies both managed + // 1. If for the same record type there are ESProductResolvers both managed // by this class and also others managed by the EventSetup, then // at IOV boundaries for this record this will fail. The EventSetup - // will invalidate all the proxies for the record after this class + // will invalidate all the resolvers for the record after this class // has set the ones it manages and they will stay invalid when they // are needed. // @@ -59,7 +60,7 @@ namespace edm { eventsetup::ESProductResolverProvider::KeyedResolversVector EventSetupTestHelper::registerResolvers( const eventsetup::EventSetupRecordKey& iRecordKey, unsigned int iovIndex) { KeyedResolversVector keyedResolversVector; - for (auto const& p : proxies_) { + for (auto const& p : resolvers_) { if (p.recordKey_ == iRecordKey) { keyedResolversVector.emplace_back(p.dataKey_, p.resolver_); } @@ -68,11 +69,11 @@ namespace edm { } std::shared_ptr EventSetupTestHelper::getResolver(unsigned int iIndex) { - return proxies_[iIndex].resolver_; + return resolvers_[iIndex].resolver_; } - void EventSetupTestHelper::resetAllProxies() { - for (auto const& p : proxies_) { + void EventSetupTestHelper::resetAllResolvers() { + for (auto const& p : resolvers_) { p.resolver_->invalidate(); } } diff --git a/FWCore/TestProcessor/src/TestProcessor.cc b/FWCore/TestProcessor/src/TestProcessor.cc index 809aa10409a8f..b10c403ee5afe 100644 --- a/FWCore/TestProcessor/src/TestProcessor.cc +++ b/FWCore/TestProcessor/src/TestProcessor.cc @@ -212,7 +212,7 @@ namespace edm { schedule_->clearCounters(); if (esHelper_) { //We want each test to have its own ES data products - esHelper_->resetAllProxies(); + esHelper_->resetAllResolvers(); } return edm::test::Event( principalCache_.eventPrincipal(0), labelOfTestModule_, processConfiguration_->processName(), result); @@ -246,7 +246,7 @@ namespace edm { if (esHelper_) { //We want each test to have its own ES data products - esHelper_->resetAllProxies(); + esHelper_->resetAllResolvers(); } return edm::test::LuminosityBlock(lumiPrincipal_, labelOfTestModule_, processConfiguration_->processName()); } @@ -278,7 +278,7 @@ namespace edm { }); if (esHelper_) { //We want each test to have its own ES data products - esHelper_->resetAllProxies(); + esHelper_->resetAllResolvers(); } return edm::test::LuminosityBlock(std::move(lumi), labelOfTestModule_, processConfiguration_->processName()); @@ -307,7 +307,7 @@ namespace edm { }); if (esHelper_) { //We want each test to have its own ES data products - esHelper_->resetAllProxies(); + esHelper_->resetAllResolvers(); } return edm::test::Run(runPrincipal_, labelOfTestModule_, processConfiguration_->processName()); } @@ -335,7 +335,7 @@ namespace edm { }); if (esHelper_) { //We want each test to have its own ES data products - esHelper_->resetAllProxies(); + esHelper_->resetAllResolvers(); } return edm::test::Run(rp, labelOfTestModule_, processConfiguration_->processName()); diff --git a/PhysicsTools/CondLiteIO/plugins/FWLiteESRecordWriterAnalyzer.cc b/PhysicsTools/CondLiteIO/plugins/FWLiteESRecordWriterAnalyzer.cc index d078787b371e3..c2ea8fa2a06b1 100644 --- a/PhysicsTools/CondLiteIO/plugins/FWLiteESRecordWriterAnalyzer.cc +++ b/PhysicsTools/CondLiteIO/plugins/FWLiteESRecordWriterAnalyzer.cc @@ -137,7 +137,7 @@ namespace edm { return; } assert(iResolverIndex.value() > -1 and - iResolverIndex.value() < static_cast(keysForProxies_.size())); + iResolverIndex.value() < static_cast(keysForResolvers_.size())); void const* pValue = this->getFromResolverAfterPrefetch(iResolverIndex, iTransientAccessOnly, oDesc, dataKey); if (nullptr == pValue) { throw cms::Exception("NoDataException")