Framework/src/ModuleHolderT.cc

0001 #include "FWCore/Framework/interface/maker/ModuleHolder.h"
0002 #include "FWCore/Framework/interface/one/EDProducerBase.h"
0003 #include "FWCore/Framework/interface/one/EDFilterBase.h"
0004 #include "FWCore/Framework/interface/one/EDAnalyzerBase.h"
0005 #include "FWCore/Framework/interface/one/OutputModuleBase.h"
0006 #include "FWCore/Framework/interface/global/EDProducerBase.h"
0007 #include "FWCore/Framework/interface/global/EDFilterBase.h"
0008 #include "FWCore/Framework/interface/global/EDAnalyzerBase.h"
0009 #include "FWCore/Framework/interface/global/OutputModuleBase.h"
0010
0011 #include "FWCore/Framework/interface/stream/EDProducerAdaptorBase.h"
0012 #include "FWCore/Framework/interface/stream/EDFilterAdaptorBase.h"
0013 #include "FWCore/Framework/interface/stream/EDAnalyzerAdaptorBase.h"
0014
0015 #include "FWCore/Framework/interface/limited/EDProducerBase.h"
0016 #include "FWCore/Framework/interface/limited/EDFilterBase.h"
0017 #include "FWCore/Framework/interface/limited/EDAnalyzerBase.h"
0018 #include "FWCore/Framework/interface/limited/OutputModuleBase.h"
0019
0020 #include "FWCore/Framework/interface/OutputModuleCommunicatorT.h"
0021
0022 namespace edm::maker {
0023   template <typename T>
0024   inline void ModuleHolderT<T>::implRegisterThinnedAssociations(ProductRegistry const& registry,
0025                                                                 ThinnedAssociationsHelper& helper) {
0026     m_mod->doRegisterThinnedAssociations(registry, helper);
0027   }
0028
0029   template <typename T>
0030   std::unique_ptr<OutputModuleCommunicator> ModuleHolderT<T>::createOutputModuleCommunicator() {
0031     return OutputModuleCommunicatorT<T>::createIfNeeded(m_mod.get());
0032   }
0033
0034   namespace {
0035     template <typename T>
0036     concept HasStreamFunctions = requires(T mod, StreamID id) {
0037       { mod.doBeginStream(id) } -> std::same_as<void>;
0038       { mod.doEndStream(id) } -> std::same_as<void>;
0039     };
0040   }  // namespace
0041
0042   template <typename T>
0043   void ModuleHolderT<T>::beginJob() {
0044     m_mod->doBeginJob();
0045   }
0046   template <typename T>
0047   void ModuleHolderT<T>::endJob() {
0048     m_mod->doEndJob();
0049   }
0050   template <typename T>
0051   void ModuleHolderT<T>::beginStream(StreamID iID) {
0052     if constexpr (HasStreamFunctions<T>) {
0053       m_mod->doBeginStream(iID);
0054     }
0055   }
0056   template <typename T>
0057   void ModuleHolderT<T>::endStream(StreamID iID) {
0058     if constexpr (HasStreamFunctions<T>) {
0059       m_mod->doEndStream(iID);
0060     }
0061   }
0062   namespace {
0063     template <typename T>
0064     bool mustPrefetchMayGet();
0065
0066     template <>
0067     bool mustPrefetchMayGet<edm::one::EDProducerBase>() {
0068       return true;
0069     }
0070     template <>
0071     bool mustPrefetchMayGet<edm::one::EDFilterBase>() {
0072       return true;
0073     }
0074     template <>
0075     bool mustPrefetchMayGet<edm::one::EDAnalyzerBase>() {
0076       return true;
0077     }
0078     template <>
0079     bool mustPrefetchMayGet<edm::one::OutputModuleBase>() {
0080       return true;
0081     }
0082
0083     template <>
0084     bool mustPrefetchMayGet<edm::global::EDProducerBase>() {
0085       return true;
0086     }
0087     template <>
0088     bool mustPrefetchMayGet<edm::global::EDFilterBase>() {
0089       return true;
0090     }
0091     template <>
0092     bool mustPrefetchMayGet<edm::global::EDAnalyzerBase>() {
0093       return true;
0094     }
0095     template <>
0096     bool mustPrefetchMayGet<edm::global::OutputModuleBase>() {
0097       return true;
0098     }
0099
0100     template <>
0101     bool mustPrefetchMayGet<edm::limited::EDProducerBase>() {
0102       return true;
0103     }
0104     template <>
0105     bool mustPrefetchMayGet<edm::limited::EDFilterBase>() {
0106       return true;
0107     }
0108     template <>
0109     bool mustPrefetchMayGet<edm::limited::EDAnalyzerBase>() {
0110       return true;
0111     }
0112     template <>
0113     bool mustPrefetchMayGet<edm::limited::OutputModuleBase>() {
0114       return true;
0115     }
0116
0117     template <>
0118     bool mustPrefetchMayGet<edm::stream::EDProducerAdaptorBase>() {
0119       return true;
0120     }
0121     template <>
0122     bool mustPrefetchMayGet<edm::stream::EDFilterAdaptorBase>() {
0123       return true;
0124     }
0125     template <>
0126     bool mustPrefetchMayGet<edm::stream::EDAnalyzerAdaptorBase>() {
0127       return true;
0128     }
0129
0130   }  // namespace
0131
0132   template <typename T>
0133   void ModuleHolderT<T>::updateLookup(BranchType iBranchType, ProductResolverIndexHelper const& iHelper) {
0134     m_mod->updateLookup(iBranchType, iHelper, mustPrefetchMayGet<T>());
0135   }
0136
0137   template <typename T>
0138   void ModuleHolderT<T>::updateLookup(eventsetup::ESRecordsToProductResolverIndices const& iPI) {
0139     m_mod->updateLookup(iPI);
0140   }
0141
0142   template <typename T>
0143   void ModuleHolderT<T>::releaseMemoryPostLookupSignal() {
0144     m_mod->releaseMemoryPostLookupSignal();
0145   }
0146
0147   template <typename T>
0148   void ModuleHolderT<T>::selectInputProcessBlocks(ProductRegistry const& productRegistry,
0149                                                   ProcessBlockHelperBase const& processBlockHelperBase) {
0150     m_mod->selectInputProcessBlocks(productRegistry, processBlockHelperBase);
0151   }
0152
0153   namespace {
0154     using ModuleToResolverIndicies =
0155         std::unordered_multimap<std::string, std::tuple<edm::TypeID const*, const char*, edm::ProductResolverIndex>>;
0156     void resolvePutIndiciesImpl(void*,
0157                                 BranchType iBranchType,
0158                                 ModuleToResolverIndicies const& iIndicies,
0159                                 std::string const& iModuleLabel) {
0160       //Do nothing
0161     }
0162
0163     void resolvePutIndiciesImpl(ProducerBase* iProd,
0164                                 BranchType iBranchType,
0165                                 ModuleToResolverIndicies const& iIndicies,
0166                                 std::string const& iModuleLabel) {
0167       iProd->resolvePutIndicies(iBranchType, iIndicies, iModuleLabel);
0168     }
0169
0170     void resolvePutIndiciesImpl(edm::stream::EDProducerAdaptorBase* iProd,
0171                                 BranchType iBranchType,
0172                                 ModuleToResolverIndicies const& iIndicies,
0173                                 std::string const& iModuleLabel) {
0174       iProd->resolvePutIndicies(iBranchType, iIndicies, iModuleLabel);
0175     }
0176     void resolvePutIndiciesImpl(edm::stream::EDFilterAdaptorBase* iProd,
0177                                 BranchType iBranchType,
0178                                 ModuleToResolverIndicies const& iIndicies,
0179                                 std::string const& iModuleLabel) {
0180       iProd->resolvePutIndicies(iBranchType, iIndicies, iModuleLabel);
0181     }
0182
0183   }  // namespace
0184
0185   template <typename T>
0186   void ModuleHolderT<T>::resolvePutIndicies(
0187       BranchType iBranchType,
0188       std::unordered_multimap<std::string, std::tuple<TypeID const*, const char*, edm::ProductResolverIndex>> const&
0189           iIndicies) {
0190     resolvePutIndiciesImpl(m_mod.get(), iBranchType, iIndicies, moduleDescription().moduleLabel());
0191   }
0192
0193   //Explicitly instantiate our needed templates to avoid having the compiler
0194   // instantiate them in all of our libraries
0195   template class ModuleHolderT<one::EDProducerBase>;
0196   template class ModuleHolderT<one::EDFilterBase>;
0197   template class ModuleHolderT<one::EDAnalyzerBase>;
0198   template class ModuleHolderT<one::OutputModuleBase>;
0199   template class ModuleHolderT<global::EDProducerBase>;
0200   template class ModuleHolderT<global::EDFilterBase>;
0201   template class ModuleHolderT<global::EDAnalyzerBase>;
0202   template class ModuleHolderT<global::OutputModuleBase>;
0203   template class ModuleHolderT<stream::EDProducerAdaptorBase>;
0204   template class ModuleHolderT<stream::EDFilterAdaptorBase>;
0205   template class ModuleHolderT<stream::EDAnalyzerAdaptorBase>;
0206   template class ModuleHolderT<limited::EDProducerBase>;
0207   template class ModuleHolderT<limited::EDFilterBase>;
0208   template class ModuleHolderT<limited::EDAnalyzerBase>;
0209   template class ModuleHolderT<limited::OutputModuleBase>;
0210
0211 }  // namespace edm::maker