Have InputTag cache EDGetToken

Dr15Jones · Dr15Jones · commit ec5043fb9c39 · 2025-08-06T09:27:11.000-05:00
Removed direct caching of ProductResolverIndex and related items and replace with EDGetToken.
diff --git a/FWCore/Framework/interface/EDConsumerBase.h b/FWCore/Framework/interface/EDConsumerBase.h
@@ -90,6 +90,15 @@ namespace edm {
     // ---------- const member functions ---------------------
     ProductResolverIndexAndSkipBit indexFrom(EDGetToken, BranchType, TypeID const&) const;
     ProductResolverIndexAndSkipBit uncheckedIndexFrom(EDGetToken) const;
+    /**returns edm::ProductResolverIndexInvalid if type and branch do not match the index
+     this can happen if the same InputTag is used for different products */
+    ProductResolverIndexAndSkipBit indexFromIfExactMatch(EDGetToken, BranchType, TypeID const&) const;
+    EDGetToken getRegisteredToken(TypeID const& typeID,
+                                  std::string const& label,
+                                  std::string const& instance,
+                                  std::string const& processName,
+                                  BranchType branchType,
+                                  bool skipCurrentProcess) const;
 
     void itemsToGet(BranchType, std::vector<ProductResolverIndexAndSkipBit>&) const;
     void itemsMayGet(BranchType, std::vector<ProductResolverIndexAndSkipBit>&) const;
diff --git a/FWCore/Framework/src/EDConsumerBase.cc b/FWCore/Framework/src/EDConsumerBase.cc
@@ -256,6 +256,44 @@ ProductResolverIndexAndSkipBit EDConsumerBase::uncheckedIndexFrom(EDGetToken iTo
   return m_tokenInfo.get<kLookupInfo>(iToken.index()).m_index;
 }
 
+ProductResolverIndexAndSkipBit EDConsumerBase::indexFromIfExactMatch(EDGetToken iToken,
+                                                                     BranchType iBranch,
+                                                                     TypeID const& iType) const {
+  if (UNLIKELY(iToken.index() >= m_tokenInfo.size())) {
+    throwBadToken(iType, iToken);
+  }
+  const auto& info = m_tokenInfo.get<kLookupInfo>(iToken.index());
+  if (LIKELY(iBranch == info.m_branchType)) {
+    if (LIKELY(iType == info.m_type)) {
+      return info.m_index;
+    }
+  }
+  return ProductResolverIndexAndSkipBit(edm::ProductResolverIndexInvalid, false);
+}
+
+EDGetToken EDConsumerBase::getRegisteredToken(TypeID const& typeID,
+                                              std::string const& label,
+                                              std::string const& instance,
+                                              std::string const& processName,
+                                              BranchType branchType,
+                                              bool skipCurrentProcess) const {
+  auto const itBegin = m_tokenInfo.begin<kLookupInfo>();
+  for (auto it = itBegin, itEnd = m_tokenInfo.end<kLookupInfo>(); it != itEnd; ++it) {
+    if (it->m_type == typeID && it->m_branchType == branchType &&
+        it->m_index.skipCurrentProcess() == skipCurrentProcess) {
+      auto index = it - itBegin;
+      auto const& labels = m_tokenInfo.get<kLabels>(index);
+      unsigned int labelStart = labels.m_startOfModuleLabel;
+      const char* moduleLabel = &(m_tokenLabels[labelStart]);
+      if (label == moduleLabel && instance == (moduleLabel + labels.m_deltaToProductInstance) &&
+          (skipCurrentProcess or (processName == (moduleLabel + labels.m_deltaToProcessName)))) {
+        return EDGetToken{static_cast<unsigned int>(index)};
+      }
+    }
+  }
+  return EDGetToken{EDGetToken::s_uninitializedValue};
+}
+
 void EDConsumerBase::itemsToGet(BranchType iBranch, std::vector<ProductResolverIndexAndSkipBit>& oIndices) const {
   //how many are we adding?
   unsigned int count = 0;
@@ -363,7 +401,8 @@ void EDConsumerBase::throwBadToken(edm::TypeID const& iType, EDGetToken iToken)
   throw cms::Exception("BadToken")
       << "A get using a EDGetToken with the C++ type '" << iType.className() << "' was made using a token with a value "
       << iToken.index()
-      << " which is beyond the range used by this module.\n Please check that the variable is being initialized from a "
+      << " which is beyond the range used by this module.\n Please check that the variable is being initialized from "
+         "a "
          "'consumes' call from this module.\n You can not share EDGetToken values between modules.";
 }
 
diff --git a/FWCore/Framework/src/Principal.cc b/FWCore/Framework/src/Principal.cc
@@ -450,16 +450,34 @@ namespace edm {
                                                    ModuleCallingContext const* mcc) const {
     bool skipCurrentProcess = inputTag.willSkipCurrentProcess();
 
-    ProductResolverIndex index = inputTag.indexFor(typeID, branchType(), &productRegistry());
+    auto token = inputTag.cachedToken();
 
+    if (token.isUninitialized() and consumer) {
+      std::string const* processName = &inputTag.process();
+      if (inputTag.process() == InputTag::kCurrentProcess) {
+        processName = &processConfiguration_->processName();
+      }
+      token = consumer->getRegisteredToken(
+          typeID, inputTag.label(), inputTag.instance(), *processName, branchType(), skipCurrentProcess);
+      if (token.isUninitialized()) {
+        failedToRegisterConsumes(kindOfType,
+                                 typeID,
+                                 inputTag.label(),
+                                 inputTag.instance(),
+                                 appendCurrentProcessIfAlias(inputTag.process(), processConfiguration_->processName()));
+      }
+      inputTag.cacheToken(token);
+    }
+    //check that the InputTag is not being used for a different type/Principal than the first call
+    auto index = consumer ? consumer->indexFromIfExactMatch(token, branchType(), typeID).productResolverIndex()
+                          : ProductResolverIndexInvalid;
     if (index == ProductResolverIndexInvalid) {
       char const* processName = inputTag.process().c_str();
       if (skipCurrentProcess) {
         processName = "\0";
       } else if (inputTag.process() == InputTag::kCurrentProcess) {
         processName = processConfiguration_->processName().c_str();
       }
-
       index =
           productLookup().index(kindOfType, typeID, inputTag.label().c_str(), inputTag.instance().c_str(), processName);
 
@@ -490,14 +508,6 @@ namespace edm {
         }
         return nullptr;
       }
-      inputTag.tryToCacheIndex(index, typeID, branchType(), &productRegistry());
-    }
-    if (UNLIKELY(consumer and (not consumer->registeredToConsume(index, skipCurrentProcess, branchType())))) {
-      failedToRegisterConsumes(kindOfType,
-                               typeID,
-                               inputTag.label(),
-                               inputTag.instance(),
-                               appendCurrentProcessIfAlias(inputTag.process(), processConfiguration_->processName()));
     }
 
     auto const& productResolver = productResolvers_[index];
diff --git a/FWCore/Utilities/interface/InputTag.h b/FWCore/Utilities/interface/InputTag.h
@@ -5,10 +5,7 @@
 #include <iosfwd>
 #include <string>
 
-#include "FWCore/Utilities/interface/TypeID.h"
-#include "FWCore/Utilities/interface/BranchType.h"
-#include "FWCore/Utilities/interface/ProductResolverIndex.h"
-#include "FWCore/Utilities/interface/thread_safety_macros.h"
+#include "FWCore/Utilities/interface/EDGetToken.h"
 
 namespace edm {
 
@@ -43,12 +40,9 @@ namespace edm {
 
     bool operator==(InputTag const& tag) const;
 
-    ProductResolverIndex indexFor(TypeID const& typeID, BranchType branchType, void const* productRegistry) const;
+    EDGetToken cachedToken() const { return token_; }
 
-    void tryToCacheIndex(ProductResolverIndex index,
-                         TypeID const& typeID,
-                         BranchType branchType,
-                         void const* productRegistry) const;
+    void cacheToken(EDGetToken) const;
 
     static const std::string kSkipCurrentProcess;
     static const std::string kCurrentProcess;
@@ -60,12 +54,7 @@ namespace edm {
     std::string instance_;
     std::string process_;
 
-    CMS_THREAD_GUARD(index_) mutable TypeID typeID_;
-    CMS_THREAD_GUARD(index_) mutable void const* productRegistry_;
-
-    mutable std::atomic<unsigned int> index_;
-
-    CMS_THREAD_GUARD(index_) mutable char branchType_;
+    mutable std::atomic<EDGetToken> token_;
 
     bool skipCurrentProcess_;
   };
diff --git a/FWCore/Utilities/src/InputTag.cc b/FWCore/Utilities/src/InputTag.cc
@@ -8,45 +8,23 @@ namespace edm {
   const std::string InputTag::kCurrentProcess("@currentProcess");
   static std::string const separator(":");
 
-  InputTag::InputTag()
-      : label_(),
-        instance_(),
-        process_(),
-        typeID_(),
-        productRegistry_(nullptr),
-        index_(ProductResolverIndexInvalid),
-        branchType_(NumBranchTypes),
-        skipCurrentProcess_(false) {}
+  InputTag::InputTag() : label_(), instance_(), process_(), token_(), skipCurrentProcess_(false) {}
 
   InputTag::InputTag(std::string const& label, std::string const& instance, std::string const& processName)
       : label_(label),
         instance_(instance),
         process_(processName),
-        typeID_(),
-        productRegistry_(nullptr),
-        index_(ProductResolverIndexInvalid),
-        branchType_(NumBranchTypes),
+        token_(),
         skipCurrentProcess_(calcSkipCurrentProcess()) {}
 
   InputTag::InputTag(char const* label, char const* instance, char const* processName)
       : label_(label),
         instance_(instance),
         process_(processName),
-        typeID_(),
-        productRegistry_(nullptr),
-        index_(ProductResolverIndexInvalid),
-        branchType_(NumBranchTypes),
+        token_(),
         skipCurrentProcess_(calcSkipCurrentProcess()) {}
 
-  InputTag::InputTag(std::string const& s)
-      : label_(),
-        instance_(),
-        process_(),
-        typeID_(),
-        productRegistry_(nullptr),
-        index_(ProductResolverIndexInvalid),
-        branchType_(NumBranchTypes),
-        skipCurrentProcess_(false) {
+  InputTag::InputTag(std::string const& s) : label_(), instance_(), process_(), token_(), skipCurrentProcess_(false) {
     // string is delimited by colons
     std::vector<std::string> tokens = tokenize(s, separator);
     size_t nwords = tokens.size();
@@ -68,57 +46,23 @@ namespace edm {
       : label_(other.label()),
         instance_(other.instance()),
         process_(other.process()),
-        typeID_(),
-        productRegistry_(nullptr),
-        index_(ProductResolverIndexInvalid),
-        branchType_(NumBranchTypes),
-        skipCurrentProcess_(other.willSkipCurrentProcess()) {
-    ProductResolverIndex otherIndex = other.index_.load();
-    if (otherIndex < ProductResolverIndexInitializing) {
-      branchType_ = other.branchType_;
-      typeID_ = other.typeID_;
-      productRegistry_ = other.productRegistry_;
-      index_.store(otherIndex);
-    }
-  }
+        token_(other.token_.load()),
+        skipCurrentProcess_(other.willSkipCurrentProcess()) {}
 
   InputTag::InputTag(InputTag&& other)
       : label_(std::move(other.label_)),
         instance_(std::move(other.instance_)),
         process_(std::move(other.process_)),
-        typeID_(),
-        productRegistry_(nullptr),
-        index_(ProductResolverIndexInvalid),
-        branchType_(NumBranchTypes),
-        skipCurrentProcess_(other.willSkipCurrentProcess()) {
-    ProductResolverIndex otherIndex = other.index_.load();
-    if (otherIndex < ProductResolverIndexInitializing) {
-      branchType_ = other.branchType_;
-      typeID_ = other.typeID_;
-      productRegistry_ = other.productRegistry_;
-      index_.store(otherIndex);
-    }
-  }
+        token_(other.token_.load()),
+        skipCurrentProcess_(other.willSkipCurrentProcess()) {}
 
   InputTag& InputTag::operator=(InputTag const& other) {
     if (this != &other) {
       label_ = other.label_;
       instance_ = other.instance_;
       process_ = other.process_;
       skipCurrentProcess_ = other.skipCurrentProcess_;
-
-      ProductResolverIndex otherIndex = other.index_.load();
-      if (otherIndex < ProductResolverIndexInitializing) {
-        branchType_ = other.branchType_;
-        typeID_ = other.typeID_;
-        productRegistry_ = other.productRegistry_;
-        index_.store(otherIndex);
-      } else {
-        branchType_ = NumBranchTypes;
-        typeID_ = TypeID();
-        productRegistry_ = nullptr;
-        index_.store(ProductResolverIndexInvalid);
-      }
+      token_.store(other.token_.load());
     }
     return *this;
   }
@@ -129,19 +73,7 @@ namespace edm {
       instance_ = std::move(other.instance_);
       process_ = std::move(other.process_);
       skipCurrentProcess_ = other.skipCurrentProcess_;
-
-      ProductResolverIndex otherIndex = other.index_.load();
-      if (otherIndex < ProductResolverIndexInitializing) {
-        branchType_ = other.branchType_;
-        typeID_ = other.typeID_;
-        productRegistry_ = other.productRegistry_;
-        index_.store(otherIndex);
-      } else {
-        branchType_ = NumBranchTypes;
-        typeID_ = TypeID();
-        productRegistry_ = nullptr;
-        index_.store(ProductResolverIndexInvalid);
-      }
+      token_.store(other.token_.load());
     }
     return *this;
   }
@@ -174,30 +106,7 @@ namespace edm {
     return (label_ == tag.label_) && (instance_ == tag.instance_) && (process_ == tag.process_);
   }
 
-  ProductResolverIndex InputTag::indexFor(TypeID const& typeID,
-                                          BranchType branchType,
-                                          void const* productRegistry) const {
-    ProductResolverIndex index = index_.load();
-
-    if (index < ProductResolverIndexInitializing && typeID_ == typeID && branchType_ == branchType &&
-        productRegistry_ == productRegistry) {
-      return index;
-    }
-    return ProductResolverIndexInvalid;
-  }
-
-  void InputTag::tryToCacheIndex(ProductResolverIndex index,
-                                 TypeID const& typeID,
-                                 BranchType branchType,
-                                 void const* productRegistry) const {
-    unsigned int invalidValue = static_cast<unsigned int>(ProductResolverIndexInvalid);
-    if (index_.compare_exchange_strong(invalidValue, static_cast<unsigned int>(ProductResolverIndexInitializing))) {
-      typeID_ = typeID;
-      branchType_ = branchType;
-      productRegistry_ = productRegistry;
-      index_.store(index);
-    }
-  }
+  void InputTag::cacheToken(EDGetToken token) const { token_.store(token); }
 
   std::ostream& operator<<(std::ostream& ost, InputTag const& tag) {
     static std::string const process(", process = ");
diff --git a/FWCore/Utilities/test/InputTag_t.cpp b/FWCore/Utilities/test/InputTag_t.cpp
@@ -10,21 +10,15 @@
 #include <string>
 
 namespace edm {
-  class ProductRegistry;
-}
+  class TestEDGetToken {
+  public:
+    static EDGetToken makeEDGetToken(unsigned int iValue) { return EDGetToken(iValue); }
+  };
+
+}  // namespace edm
 
 // This is just for the test. Do not dereference the pointers.
 // They points to nothing legal.
-edm::ProductRegistry* reg1 = reinterpret_cast<edm::ProductRegistry*>(1);
-edm::ProductRegistry* reg2 = reinterpret_cast<edm::ProductRegistry*>(2);
-
-class TypeToTestInputTag1 {};
-class TypeToTestInputTag2 {};
-TypeToTestInputTag1 typeToTestInputTag1;
-TypeToTestInputTag2 typeToTestInputTag2;
-
-edm::TypeID testTypeID1(typeToTestInputTag1);
-edm::TypeID testTypeID2(typeToTestInputTag2);
 
 class InputTagModifier {
   edm::InputTag* inputTag;
@@ -35,20 +29,20 @@ class InputTagModifier {
   void operator()(oneapi::tbb::blocked_range<int> const& r) const {
     for (int i = r.begin(); i != r.end(); i++) {
       for (unsigned int j = 0; j < 10000; ++j) {
-        unsigned int index = inputTag->indexFor(testTypeID1, edm::InRun, reg1);
-        if (index != 5 && index != edm::ProductResolverIndexInvalid)
+        unsigned int index = inputTag->cachedToken().index();
+        if (index != 5 && index != edm::EDGetToken().index())
           abort();
         // std::cout << "a\n";
       }
       for (unsigned int j = 0; j < 100; ++j) {
-        inputTag->tryToCacheIndex(5, testTypeID1, edm::InRun, reg1);
+        inputTag->cacheToken(edm::TestEDGetToken::makeEDGetToken(5));
         // std::cout << "b\n";
       }
       for (unsigned int j = 0; j < 1000; ++j) {
-        unsigned int index = inputTag->indexFor(testTypeID1, edm::InRun, reg1);
+        unsigned int index = inputTag->cachedToken().index();
         // if (index != 5) abort(); // This can fail!
         // std::cout << index << " c\n";
-        if (index != 5 && index != edm::ProductResolverIndexInvalid)
+        if (index != 5 && index != edm::EDGetToken().index())
           abort();
       }
     }
diff --git a/FWCore/Utilities/test/test_catch2_InputTag.cc b/FWCore/Utilities/test/test_catch2_InputTag.cc
