Refactor consumes info for PathsAndConsumesOfModules

- moved complex logic for creating the internal data structures to the class itself
- can no ask an ESProducer what is produces
- provide a mechanism to get minimal information about what ES products are being consumed

Author: Dr15Jones

FWCore/Framework/interface/EDConsumerBase.h

@@ -37,6 +37,7 @@
 #include "FWCore/Framework/interface/HCTypeTag.h"
 #include "FWCore/Framework/interface/DataKey.h"
 #include "FWCore/Framework/interface/data_default_record_trait.h"
+#include "FWCore/Framework/interface/ModuleConsumesMinimalESInfo.h"
 #include "FWCore/ServiceRegistry/interface/ServiceRegistryfwd.h"
 #include "FWCore/Utilities/interface/BranchType.h"
 #include "FWCore/Utilities/interface/ESIndices.h"
@@ -114,20 +115,12 @@ namespace edm {
     typedef ProductLabels Labels;
     void labelsForToken(EDGetToken iToken, Labels& oLabels) const;
 
-    void modulesWhoseProductsAreConsumed(std::array<std::vector<ModuleDescription const*>*, NumBranchTypes>& modulesAll,
-                                         ProductRegistry const& preg,
-                                         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<ModuleConsumesInfo> moduleConsumesInfos() const;
-    std::vector<ModuleConsumesESInfo> moduleConsumesESInfos(eventsetup::ESRecordsToProductResolverIndices const&) const;
+    ///This can only be called before the end of beginJob (after that the underlying data has been deleted)
+    std::vector<ModuleConsumesMinimalESInfo> moduleConsumesMinimalESInfos() const;
 
     ESResolverIndex const* esGetTokenIndices(edm::Transition iTrans) const {
       if (iTrans < edm::Transition::NumberOfEventSetupTransitions) {
@@ -232,6 +225,20 @@ namespace edm {
       return ESGetTokenGeneric(static_cast<unsigned int>(Tr), index, iRecord.type());
     }
 
+    /**The passed functor must take the following signature
+     *  F( ModuleConsumesInfo const& )
+     * The functor will be called for each consumed EDProduct registered for the module
+     */
+    template <typename F>
+    void consumedProducts(F&& iFunc) const;
+
+    /**The passed functor must take the following signature
+     * F(edm::ModuleConsumesMinimalESInfo const& )
+     * The functor will be called for each consumed ESProduct registered for the module
+     */
+    template <typename F>
+    void consumedESProducts(F&& iFunct) const;
+
   private:
     virtual void extendUpdateLookup(BranchType iBranchType, ProductResolverIndexHelper const&);
     virtual void registerLateConsumes(eventsetup::ESRecordsToProductResolverIndices const&) {}
@@ -326,6 +333,47 @@ namespace edm {
     bool containsCurrentProcessAlias_;
   };
 
+  template <typename F>
+  void EDConsumerBase::consumedProducts(F&& iFunc) const {
+    auto itKind = m_tokenInfo.begin<kKind>();
+    auto itLabels = m_tokenInfo.begin<kLabels>();
+    auto itAlways = m_tokenInfo.begin<kAlwaysGets>();
+    for (auto itInfo = m_tokenInfo.begin<kLookupInfo>(), itEnd = m_tokenInfo.end<kLookupInfo>(); itInfo != itEnd;
+         ++itInfo, ++itKind, ++itLabels, ++itAlways) {
+      auto labels = *itLabels;
+      unsigned int start = labels.m_startOfModuleLabel;
+      auto module = &(m_tokenLabels[start]);
+      auto productInstance = module + labels.m_deltaToProductInstance;
+      auto process = module + labels.m_deltaToProcessName;
+
+      iFunc(ModuleConsumesInfo(itInfo->m_type,
+                               module,
+                               productInstance,
+                               process,
+                               itInfo->m_branchType,
+                               *itKind,
+                               *itAlways,
+                               itInfo->m_index.skipCurrentProcess()));
+    }
+  }
+
+  template <typename F>
+  void EDConsumerBase::consumedESProducts(F&& iFunc) const {
+    unsigned int index = 0;
+    auto itResolverIndex = esTokenLookupInfoContainer().begin<kESResolverIndex>();
+    for (auto it = esTokenLookupInfoContainer().begin<kESLookupInfo>();
+         it != esTokenLookupInfoContainer().end<kESLookupInfo>();
+         ++it, ++index, ++itResolverIndex) {
+      //NOTE: memory for it->m_key is passed on to call via the ModuleConsumesMinimalESInfo constructor
+      // this avoids a copy and avoids code later in the call chain accidently using deleted memory
+      iFunc(ModuleConsumesMinimalESInfo(static_cast<Transition>(consumesIndexConverter()[index].first),
+                                        it->m_record,
+                                        it->m_key,
+                                        &(m_tokenLabels[it->m_startOfComponentName]),
+                                        *itResolverIndex));
+    }
+  }
+
   template <Transition TR>
   class EDConsumerBaseESAdaptor {
   public:

FWCore/Framework/interface/ESModuleConsumesMinimalInfo.h

@@ -0,0 +1,38 @@
+#ifndef FWCore_Framework_ESModuleConsumesMinimalInfo_h
+#define FWCore_Framework_ESModuleConsumesMinimalInfo_h
+
+// -*- C++ -*-
+// Package:     FWCore/Framework
+// Class  :     ESModuleConsumesMinimalInfo
+// Minimal information about the consumes call for an EventSetup product by an ESModule
+
+#include "FWCore/Utilities/interface/ESIndices.h"
+#include "FWCore/Framework/interface/EventSetupRecordKey.h"
+#include "FWCore/Framework/interface/DataKey.h"
+#include <string_view>
+
+namespace edm::eventsetup {
+  struct ESModuleConsumesMinimalInfo {
+    ESModuleConsumesMinimalInfo(unsigned int iProduceMethodID,
+                                eventsetup::EventSetupRecordKey const& iRecord,
+                                eventsetup::DataKey const& iDataKey,
+                                std::string_view iComponentLabel)
+        : recordForDataKey_(iRecord),
+          dataKey_(iDataKey.type(), iDataKey.name(), eventsetup::DataKey::DoNotCopyMemory()),
+          componentLabel_(iComponentLabel),
+          produceMethodID_(iProduceMethodID) {}
+    ESModuleConsumesMinimalInfo() = default;
+    ESModuleConsumesMinimalInfo(ESModuleConsumesMinimalInfo&&) = default;
+    ESModuleConsumesMinimalInfo& operator=(ESModuleConsumesMinimalInfo&&) = default;
+
+    // avoid accidentally copying data key as the strings would be copied instead of shared
+    ESModuleConsumesMinimalInfo(ESModuleConsumesMinimalInfo const&) = delete;
+    ESModuleConsumesMinimalInfo& operator=(ESModuleConsumesMinimalInfo const&) = delete;
+
+    eventsetup::EventSetupRecordKey recordForDataKey_;
+    eventsetup::DataKey dataKey_;
+    std::string_view componentLabel_;
+    unsigned int produceMethodID_ = 0;
+  };
+}  // namespace edm::eventsetup
+#endif  // FWCore_Framework_ESModuleConsumesMinimalInfo_h

FWCore/Framework/interface/ESModuleProducesInfo.h

@@ -0,0 +1,29 @@
+#ifndef FWCore_Framework_ESModuleProducesInfo_h
+#define FWCore_Framework_ESModuleProducesInfo_h
+// -*- C++ -*-
+
+// Package:     Framework
+// Class  :     ESModuleProducesInfo
+//
+// Description: Contains information about which products
+// a module declares it will produce from the EventSetup.
+
+#include "FWCore/Framework/interface/DataKey.h"
+#include "FWCore/Framework/interface/EventSetupRecordKey.h"
+namespace edm::eventsetup {
+  class ESModuleProducesInfo {
+  public:
+    ESModuleProducesInfo(EventSetupRecordKey const& iRecord, DataKey const& iDataKey, unsigned int iProduceMethodID)
+        : record_(iRecord), dataKey_(iDataKey), produceMethodID_(iProduceMethodID) {}
+
+    EventSetupRecordKey const& record() const { return record_; }
+    DataKey const& dataKey() const { return dataKey_; }
+    unsigned int produceMethodID() const { return produceMethodID_; }
+
+  private:
+    EventSetupRecordKey record_;
+    DataKey dataKey_;
+    unsigned int produceMethodID_;
+  };
+}  // namespace edm::eventsetup
+#endif

FWCore/Framework/interface/ESProducer.h

@@ -95,6 +95,7 @@ namespace edm {
   namespace eventsetup {
     struct ComponentDescription;
     class ESRecordsToProductResolverIndices;
+    class ESModuleConsumesMinimalInfo;
 
     //used by ESProducer to create the proper Decorator based on the
     //  argument type passed.  The default it to just 'pass through'
@@ -158,12 +159,14 @@ 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;
 
+    /** Returns a vector of ESModuleConsumesMinimalInfo.
+        Each entry contains minimal information about the products that a method consumes.
+    */
+    std::vector<eventsetup::ESModuleConsumesMinimalInfo> esModuleConsumesMinimalInfos() const;
+
   protected:
     /** Specify the names of the shared resources used by this ESProducer */
     void usesResources(std::vector<std::string> const&);

FWCore/Framework/interface/ESProductResolverArgumentFactoryTemplate.h

@@ -65,6 +65,8 @@ namespace edm {
         return DataKey(DataKey::makeTypeTag<typename ResolverType::ValueType>(), iName.c_str());
       }
 
+      unsigned int produceMethodID() const override { return callback_->second->produceMethodID(); }
+
     private:
       std::shared_ptr<std::pair<unsigned int, std::shared_ptr<CallbackType>>> callback_;
     };

FWCore/Framework/interface/ESProductResolverFactoryBase.h

@@ -40,6 +40,8 @@ namespace edm {
       virtual std::unique_ptr<ESProductResolver> makeResolver(unsigned int iovIndex) = 0;
 
       virtual DataKey makeKey(const std::string& iName) const = 0;
+
+      virtual unsigned int produceMethodID() const = 0;
     };
   }  // namespace eventsetup
 }  // namespace edm

FWCore/Framework/interface/ESProductResolverFactoryProducer.h

@@ -83,6 +83,8 @@ namespace edm {
 
     ~ESProductResolverFactoryProducer() noexcept(false) override;
 
+    std::vector<eventsetup::ESModuleProducesInfo> producesInfo() const override;
+
   protected:
     using EventSetupRecordKey = eventsetup::EventSetupRecordKey;
 

FWCore/Framework/interface/ESProductResolverProvider.h

@@ -60,6 +60,7 @@ namespace edm {
   namespace eventsetup {
     class ESProductResolver;
     class ESRecordsToProductResolverIndices;
+    class ESModuleProducesInfo;
 
     class ESProductResolverProvider {
     public:
@@ -161,6 +162,10 @@ namespace edm {
       void fillRecordsNotAllowingConcurrentIOVs(std::set<EventSetupRecordKey>& recordsNotAllowingConcurrentIOVs) const {
         productResolverContainer_.fillRecordsNotAllowingConcurrentIOVs(recordsNotAllowingConcurrentIOVs);
       }
+      /// @brief Provides information about each product that this module produces.
+      /// If the value of produceMethodID is same for different infos it means they are produced by the same call.
+      /// @return the vector of ESModuleProducesInfo objects, one for each product produced by this module.
+      virtual std::vector<ESModuleProducesInfo> producesInfo() const = 0;
 
       virtual void initConcurrentIOVs(EventSetupRecordKey const& key, unsigned int nConcurrentIOVs) {}
 

FWCore/Framework/interface/ESTagGetter.h

@@ -10,7 +10,9 @@
  Description: Used with mayConsume option of ESConsumesCollector
 
  Usage:
-    <usage>
+    This contains a cache of data about all Resolvers which are
+    associated with data produces which are in the Record and which
+    are of the proper type.
 
 */
 //

FWCore/Framework/interface/ModuleConsumesMinimalESInfo.h

@@ -0,0 +1,41 @@
+#ifndef FWCore_Framework_ModuleConsumesMinimalESInfo_h
+#define FWCore_Framework_ModuleConsumesMinimalESInfo_h
+
+// -*- C++ -*-
+// Package:     FWCore/Framework
+// Class  :     ModuleConsumesMinimalESInfo
+// Minimal information about the consumes call for an EventSetup product
+// requested from an ED module
+
+#include "FWCore/Utilities/interface/Transition.h"
+#include "FWCore/Utilities/interface/ESIndices.h"
+#include "FWCore/Framework/interface/EventSetupRecordKey.h"
+#include "FWCore/Framework/interface/DataKey.h"
+#include <string_view>
+
+namespace edm {
+  struct ModuleConsumesMinimalESInfo {
+    ModuleConsumesMinimalESInfo(Transition iTransition,
+                                eventsetup::EventSetupRecordKey const& iRecord,
+                                eventsetup::DataKey const& iDataKey,
+                                std::string_view iComponentLabel,
+                                ESResolverIndex iIndex)
+        : transition_(iTransition),
+          record_(iRecord),
+          dataKey_(iDataKey.type(), iDataKey.name(), eventsetup::DataKey::DoNotCopyMemory()),
+          componentLabel_(iComponentLabel) {}
+    ModuleConsumesMinimalESInfo() = default;
+    ModuleConsumesMinimalESInfo(ModuleConsumesMinimalESInfo&&) = default;
+    ModuleConsumesMinimalESInfo& operator=(ModuleConsumesMinimalESInfo&&) = default;
+
+    //want to avoid accidently copying dataKey_
+    ModuleConsumesMinimalESInfo(ModuleConsumesMinimalESInfo const&) = delete;
+    ModuleConsumesMinimalESInfo& operator=(ModuleConsumesMinimalESInfo const&) = delete;
+
+    edm::Transition transition_;
+    eventsetup::EventSetupRecordKey record_;
+    eventsetup::DataKey dataKey_;
+    std::string_view componentLabel_;
+  };
+}  // namespace edm
+#endif  // FWCore_Framework_ModuleConsumesMinimalESInfo_h