Print ES module dependences from Tracer

Author: wddgit

FWCore/Framework/interface/Callback.h

@@ -49,7 +49,7 @@ namespace edm {
           : Callback(iProd, std::make_shared<TProduceFunc>(std::move(iProduceFunc)), iID, iDec) {}
 
       Callback* clone() {
-        return new Callback(Base::producer(), Base::produceFunction(), Base::transitionID(), Base::decorator());
+        return new Callback(Base::producer(), Base::produceFunction(), Base::produceMethodID(), Base::decorator());
       }
 
       void prefetchAsync(WaitingTaskHolder iTask,

FWCore/Framework/interface/CallbackBase.h

@@ -72,7 +72,7 @@ namespace edm {
             producer_(iProd),
             callingContext_(&iProd->description(), iID),
             produceFunction_(std::move(iProduceFunc)),
-            id_(iID),
+            produceMethodID_(iID),
             wasCalledForThisRecord_(false),
             decorator_(iDec) {}
 
@@ -133,7 +133,7 @@ namespace edm {
                         }
                         TRecord rec;
                         ESParentContext pc{&context};
-                        rec.setImpl(record, transitionID(), resolvers, eventSetupImpl, &pc);
+                        rec.setImpl(record, produceMethodID(), resolvers, eventSetupImpl, &pc);
                         ServiceRegistry::Operate operate(serviceToken.lock());
                         record->activityRegistry()->preESModuleSignal_.emit(record->key(), context);
                         struct EndGuard {
@@ -221,8 +221,8 @@ namespace edm {
         taskList_.reset();
       }
 
-      unsigned int transitionID() const noexcept { return id_; }
-      ESResolverIndex const* getTokenIndices() const noexcept { return producer_->getTokenIndices(id_); }
+      unsigned int produceMethodID() const noexcept { return produceMethodID_; }
+      ESResolverIndex const* getTokenIndices() const noexcept { return producer_->getTokenIndices(produceMethodID_); }
 
       std::optional<std::vector<ESResolverIndex>> const& postMayGetResolvers() const { return postMayGetResolvers_; }
       T* producer() noexcept { return producer_.get(); }
@@ -245,8 +245,8 @@ namespace edm {
                                    EventSetupImpl const* iImpl,
                                    ESResolverIndex const* resolvers,
                                    ServiceToken const& token) const noexcept {
-        auto recs = producer_->getTokenRecordIndices(id_);
-        auto n = producer_->numberOfTokenIndices(id_);
+        auto recs = producer_->getTokenRecordIndices(produceMethodID_);
+        auto n = producer_->numberOfTokenIndices(produceMethodID_);
         for (size_t i = 0; i != n; ++i) {
           auto rec = iImpl->findImpl(recs[i]);
           if (rec) {
@@ -259,8 +259,8 @@ namespace edm {
         //Handle mayGets
         TRecord rec;
         ESParentContext pc{&callingContext_};
-        rec.setImpl(iRecord, transitionID(), getTokenIndices(), iEventSetupImpl, &pc);
-        postMayGetResolvers_ = producer_->updateFromMayConsumes(id_, rec);
+        rec.setImpl(iRecord, produceMethodID(), getTokenIndices(), iEventSetupImpl, &pc);
+        postMayGetResolvers_ = producer_->updateFromMayConsumes(produceMethodID_, rec);
         return static_cast<bool>(postMayGetResolvers_);
       }
 
@@ -272,8 +272,8 @@ namespace edm {
       // Using std::shared_ptr in order to share the state of the
       // functors across all clones
       std::shared_ptr<TProduceFunc> produceFunction_;
-      // This transition id identifies which setWhatProduced call this Callback is associated with
-      const unsigned int id_;
+      // produceMethodID_ identifies which setWhatProduced call this Callback is associated with
+      const unsigned int produceMethodID_;
       std::atomic<bool> wasCalledForThisRecord_;
       TDecorator decorator_;
     };

FWCore/Framework/interface/CallbackExternalWork.h

@@ -94,7 +94,7 @@ namespace edm {
 
       CallbackExternalWork* clone() {
         return new CallbackExternalWork(
-            Base::producer(), acquireFunction_, Base::produceFunction(), Base::transitionID(), Base::decorator());
+            Base::producer(), acquireFunction_, Base::produceFunction(), Base::produceMethodID(), Base::decorator());
       }
 
       void prefetchAsync(WaitingTaskHolder iTask,
@@ -177,7 +177,7 @@ namespace edm {
                             }
                             TRecord rec;
                             edm::ESParentContext pc{&context};
-                            rec.setImpl(record, Base::transitionID(), resolvers, eventSetupImpl, &pc);
+                            rec.setImpl(record, Base::produceMethodID(), resolvers, eventSetupImpl, &pc);
                             ServiceRegistry::Operate operate(serviceToken.lock());
                             record->activityRegistry()->preESModuleAcquireSignal_.emit(record->key(), context);
                             struct EndGuard {

FWCore/Framework/interface/CallbackProductResolver.h

@@ -1,11 +1,11 @@
+// -*- C++ -*-
 #ifndef Framework_CallbackProductResolver_h
 #define Framework_CallbackProductResolver_h
-// -*- C++ -*-
 //
 // Package:     Framework
 // Class  :     CallbackProductResolver
 //
-/**\class CallbackProductResolver CallbackProductResolver.h FWCore/Framework/interface/CallbackProductResolver.h
+/**\class edm::eventsetup::CallbackProductResolver
 
  Description: A ESProductResolver which performs a callback when data is requested
 
@@ -75,6 +75,8 @@ namespace edm::eventsetup {
     CallbackProductResolver(const CallbackProductResolver&) = delete;
     const CallbackProductResolver& operator=(const CallbackProductResolver&) = delete;
 
+    unsigned int produceMethodID() const final { return callback_->produceMethodID(); }
+
   private:
     DataT data_{};
     edm::propagate_const<std::shared_ptr<CallbackT>> callback_;

FWCore/Framework/interface/DependentRecordImplementation.h

@@ -1,11 +1,11 @@
+// -*- C++ -*-
 #ifndef FWCore_Framework_DependentRecordImplementation_h
 #define FWCore_Framework_DependentRecordImplementation_h
-// -*- C++ -*-
 //
 // Package:     Framework
 // Class  :     DependentRecordImplementation
 //
-/**\class DependentRecordImplementation DependentRecordImplementation.h FWCore/Framework/interface/DependentRecordImplementation.h
+/**\class edm::eventsetup::DependentRecordImplementation
 
  Description: <one line class summary>
 

FWCore/Framework/interface/EDConsumerBase.h

@@ -1,6 +1,6 @@
+// -*- C++ -*-
 #ifndef FWCore_Framework_EDConsumerBase_h
 #define FWCore_Framework_EDConsumerBase_h
-// -*- C++ -*-
 //
 // Package:     FWCore/Framework
 // Class  :     EDConsumerBase
@@ -21,22 +21,24 @@
 // system include files
 #include <array>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 #include <array>
 #include <cassert>
 #include <tuple>
+#include <utility>
 
 // user include files
-#include "DataFormats/Provenance/interface/BranchType.h"
 #include "DataFormats/Provenance/interface/ProvenanceFwd.h"
 #include "FWCore/Common/interface/FWCoreCommonFwd.h"
 #include "FWCore/Framework/interface/ProductResolverIndexAndSkipBit.h"
 #include "FWCore/Framework/interface/EventSetupRecordKey.h"
 #include "FWCore/Framework/interface/HCTypeTag.h"
 #include "FWCore/Framework/interface/DataKey.h"
 #include "FWCore/Framework/interface/data_default_record_trait.h"
-#include "FWCore/ServiceRegistry/interface/ConsumesInfo.h"
+#include "FWCore/ServiceRegistry/interface/ServiceRegistryfwd.h"
+#include "FWCore/Utilities/interface/BranchType.h"
 #include "FWCore/Utilities/interface/ESIndices.h"
 #include "FWCore/Utilities/interface/TypeID.h"
 #include "FWCore/Utilities/interface/TypeToGet.h"
@@ -67,8 +69,9 @@ namespace edm {
   class WillGetIfMatch;
 
   namespace eventsetup {
+    struct ComponentDescription;
     class ESRecordsToProductResolverIndices;
-  }
+  }  // namespace eventsetup
 
   class EDConsumerBase {
   public:
@@ -103,6 +106,7 @@ namespace edm {
     // ---------- member functions ---------------------------
     void updateLookup(BranchType iBranchType, ProductResolverIndexHelper const&, bool iPrefetchMayGet);
     void updateLookup(eventsetup::ESRecordsToProductResolverIndices const&);
+    void releaseMemoryPostLookupSignal();
     void selectInputProcessBlocks(ProductRegistry const& productRegistry,
                                   ProcessBlockHelperBase const& processBlockHelperBase) {
       doSelectInputProcessBlocks(productRegistry, processBlockHelperBase);
@@ -117,10 +121,15 @@ namespace edm {
                                          std::map<std::string, ModuleDescription const*> const& labelsToDesc,
                                          std::string const& processName) const;
 
+    void esModulesWhoseProductsAreConsumed(
+        std::array<std::vector<eventsetup::ComponentDescription const*>*, kNumberOfEventSetupTransitions>& esModules,
+        eventsetup::ESRecordsToProductResolverIndices const&) const;
+
     /// Convert "@currentProcess" in InputTag process names to the actual current process name.
     void convertCurrentProcessAlias(std::string const& processName);
 
-    std::vector<ConsumesInfo> consumesInfo() const;
+    std::vector<ModuleConsumesInfo> moduleConsumesInfos() const;
+    std::vector<ModuleConsumesESInfo> moduleConsumesESInfos(eventsetup::ESRecordsToProductResolverIndices const&) const;
 
     ESResolverIndex const* esGetTokenIndices(edm::Transition iTrans) const {
       if (iTrans < edm::Transition::NumberOfEventSetupTransitions) {
@@ -250,6 +259,31 @@ namespace edm {
 
     virtual void doSelectInputProcessBlocks(ProductRegistry const&, ProcessBlockHelperBase const&);
 
+    struct ESTokenLookupInfo {
+      eventsetup::EventSetupRecordKey m_record;
+      eventsetup::DataKey m_key;
+      unsigned int m_startOfComponentName;
+    };
+
+    enum { kESLookupInfo, kESResolverIndex };
+
+    using ESTokenLookupInfoContainer = edm::SoATuple<ESTokenLookupInfo, ESResolverIndex>;
+
+    ESTokenLookupInfoContainer const& esTokenLookupInfoContainer() const {
+      return esDataThatCanBeDeletedEarly_->esTokenLookupInfoContainer_;
+    }
+
+    using ESResolverIndexContainer = std::array<std::vector<ESResolverIndex>, kNumberOfEventSetupTransitions>;
+
+    using ConsumesIndexConverter =
+        std::vector<std::pair<ESResolverIndexContainer::size_type, std::vector<ESResolverIndex>::size_type>>;
+
+    // This can be used to convert from an index used to access esTokenLookupInfoContainer_
+    // into the 2 indexes needed to access esItemsToGetFromTransition_
+    ConsumesIndexConverter const& consumesIndexConverter() const {
+      return esDataThatCanBeDeletedEarly_->consumesIndexConverter_;
+    }
+
     // ---------- member data --------------------------------
 
     struct TokenLookupInfo {
@@ -282,27 +316,17 @@ namespace edm {
 
     std::array<std::vector<ProductResolverIndexAndSkipBit>, edm::NumBranchTypes> itemsToGetFromBranch_;
 
-    struct ESTokenLookupInfo {
-      eventsetup::EventSetupRecordKey m_record;
-      eventsetup::DataKey m_key;
-      unsigned int m_startOfComponentName;
+    struct ESDataThatCanBeDeletedEarly {
+      ESTokenLookupInfoContainer esTokenLookupInfoContainer_;
+      ConsumesIndexConverter consumesIndexConverter_;
     };
 
-    // TODO We would like to be able to access m_esTokenInfo from the
-    // index in the token, but this is currently not possible. One idea
-    // for this is to order the entries in m_esToken so that all the ones
-    // for transition 0 come first, then the ones for for transition 1
-    // and so on for all the transitions. Within a transition, the
-    // entries would be in the same order in m_esTokenInfo and
-    // esItemsToGetFromTransition_. This is something for future
-    // development and might require a change to SoATuple to support
-    // inserts in the middle of the data structure.
-    enum { kESLookupInfo, kESResolverIndex };
-    edm::SoATuple<ESTokenLookupInfo, ESResolverIndex> m_esTokenInfo;
-    std::array<std::vector<ESResolverIndex>, static_cast<unsigned int>(edm::Transition::NumberOfEventSetupTransitions)>
-        esItemsToGetFromTransition_;
-    std::array<std::vector<ESRecordIndex>, static_cast<unsigned int>(edm::Transition::NumberOfEventSetupTransitions)>
-        esRecordsToGetFromTransition_;
+    std::unique_ptr<ESDataThatCanBeDeletedEarly> esDataThatCanBeDeletedEarly_;
+
+    ESResolverIndexContainer esItemsToGetFromTransition_;
+
+    std::array<std::vector<ESRecordIndex>, kNumberOfEventSetupTransitions> esRecordsToGetFromTransition_;
+
     bool frozen_;
     bool containsCurrentProcessAlias_;
   };

FWCore/Framework/interface/ESConsumesCollector.h

@@ -1,11 +1,11 @@
+// -*- C++ -*-
 #ifndef FWCore_Framework_ESConsumesCollector_h
 #define FWCore_Framework_ESConsumesCollector_h
-// -*- C++ -*-
 //
 // Package:     FWCore/Framework
 // Class  :     edm::ConsumesCollector
 //
-/**\class edm::ESConsumesCollector ESConsumesCollector.h "FWCore/Framework/interface/ESConsumesCollector.h"
+/**\class edm::ESConsumesCollector
 
  Description: Helper class to gather consumes information for the EventSetup.
 
@@ -80,7 +80,7 @@ namespace edm {
                                nullptr);
       //even though m_consumer may expand, the address for
       // name().value() remains the same since it is 'moved'.
-      return ESGetToken<Product, Record>{m_transitionID, index, m_consumer->back().productKey_.name().value()};
+      return ESGetToken<Product, Record>{m_produceMethodID, index, m_consumer->back().productKey_.name().value()};
     }
 
     template <typename Product, typename Record>
@@ -91,15 +91,15 @@ namespace edm {
           EventSetupRecordKey::makeKey<Record>(), DataKey(DataKey::makeTypeTag<Product>(), ""), "", nullptr);
       //even though m_consumer may expand, the address for
       // name().value() remains the same since it is 'moved'.
-      return ESGetToken<Product, Record>{m_transitionID, index, m_consumer->back().productKey_.name().value()};
+      return ESGetToken<Product, Record>{m_produceMethodID, index, m_consumer->back().productKey_.name().value()};
     }
 
     ESConsumesCollectorAdaptor consumes();
     ESConsumesCollectorWithTagAdaptor consumes(ESInputTag tag);
 
   protected:
-    explicit ESConsumesCollector(ESConsumesInfo* const iConsumer, unsigned int iTransitionID)
-        : m_consumer{iConsumer}, m_transitionID{iTransitionID} {}
+    explicit ESConsumesCollector(ESConsumesInfo* const iConsumer, unsigned int iProduceMethodID)
+        : m_consumer{iConsumer}, m_produceMethodID{iProduceMethodID} {}
 
     template <typename Product, typename Record, typename Collector, typename PTag>
     auto registerMayConsume(std::unique_ptr<Collector> iCollector, PTag const& productTag) {
@@ -115,13 +115,13 @@ namespace edm {
                                std::move(iCollector));
       //even though m_consumer may expand, the address for
       // name().value() remains the same since it is 'moved'.
-      return ESGetToken<Product, Record>{m_transitionID, index, m_consumer->back().productKey_.name().value()};
+      return ESGetToken<Product, Record>{m_produceMethodID, index, m_consumer->back().productKey_.name().value()};
     }
 
   private:
     // ---------- member data --------------------------------
     edm::propagate_const<ESConsumesInfo*> m_consumer{nullptr};
-    unsigned int m_transitionID{0};
+    unsigned int m_produceMethodID{0};
   };
 
   template <typename RECORD>

FWCore/Framework/interface/ESProducer.h

@@ -72,6 +72,7 @@ Example: two algorithms each creating only one objects
 #include <memory>
 #include <string>
 #include <optional>
+#include <vector>
 
 // user include files
 #include "FWCore/Framework/interface/ESConsumesCollector.h"
@@ -87,11 +88,14 @@ Example: two algorithms each creating only one objects
 #include "FWCore/Framework/interface/es_Label.h"
 
 #include "FWCore/Framework/interface/SharedResourcesAcquirer.h"
+#include "FWCore/ServiceRegistry/interface/ServiceRegistryfwd.h"
 
 // forward declarations
 namespace edm {
   namespace eventsetup {
+    struct ComponentDescription;
     class ESRecordsToProductResolverIndices;
+
     //used by ESProducer to create the proper Decorator based on the
     //  argument type passed.  The default it to just 'pass through'
     //  the argument as the decorator itself
@@ -154,6 +158,12 @@ namespace edm {
 
     SerialTaskQueueChain& queue() { return acquirer_.serialQueueChain(); }
 
+    void esModulesWhoseProductsAreConsumed(std::vector<eventsetup::ComponentDescription const*>& esModules,
+                                           eventsetup::ESRecordsToProductResolverIndices const&) const;
+
+    std::vector<std::vector<ESModuleConsumesInfo>> esModuleConsumesInfos(
+        eventsetup::ESRecordsToProductResolverIndices const&) const;
+
   protected:
     /** Specify the names of the shared resources used by this ESProducer */
     void usesResources(std::vector<std::string> const&);
@@ -226,18 +236,19 @@ namespace edm {
 
     template <typename TReturn, typename TRecord, typename TFunc, typename TDecorator>
     ESConsumesCollectorT<TRecord> setWhatProduced(TFunc&& func, TDecorator&& iDec, const es::Label& iLabel = {}) {
-      const auto id = consumesInfoSize();
+      const auto produceMethodID = consumesInfoSize();
       using DecoratorType = std::decay_t<TDecorator>;
       using CallbackType = eventsetup::Callback<ESProducer, TFunc, TReturn, TRecord, DecoratorType>;
       unsigned int iovIndex = 0;  // Start with 0, but later will cycle through all of them
-      auto temp = std::make_shared<CallbackType>(this, std::forward<TFunc>(func), id, std::forward<TDecorator>(iDec));
+      auto temp = std::make_shared<CallbackType>(
+          this, std::forward<TFunc>(func), produceMethodID, std::forward<TDecorator>(iDec));
       auto callback =
           std::make_shared<std::pair<unsigned int, std::shared_ptr<CallbackType>>>(iovIndex, std::move(temp));
       registerProducts(std::move(callback),
                        static_cast<const typename eventsetup::produce::product_traits<TReturn>::type*>(nullptr),
                        static_cast<const TRecord*>(nullptr),
                        iLabel);
-      return ESConsumesCollectorT<TRecord>(consumesInfoPushBackNew(), id);
+      return ESConsumesCollectorT<TRecord>(consumesInfoPushBackNew(), produceMethodID);
     }
 
     // These next four functions are intended for use in this class and

FWCore/Framework/interface/ESProductResolver.h

@@ -71,6 +71,10 @@ namespace edm {
 
       virtual void initializeForNewIOV() {}
 
+      // Counts setWhatProduced calls if creating module class derives from ESProducer.
+      // Currently, all others cases always return 0 (CondDBESSource, unit tests...).
+      virtual unsigned int produceMethodID() const;
+
     protected:
       /**This is the function which does the real work of getting the data if it is not
           already cached.  The returning 'void const*' must point to an instance of the class