Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2023-10-25 09:47:04 

0001 #include "FWCore/Framework/interface/maker/WorkerT.h"
0002 #include "FWCore/Framework/interface/EventPrincipal.h"
0003 
0004 #include "FWCore/Framework/interface/one/EDProducerBase.h"
0005 #include "FWCore/Framework/interface/one/EDFilterBase.h"
0006 #include "FWCore/Framework/interface/one/EDAnalyzerBase.h"
0007 #include "FWCore/Framework/interface/one/OutputModuleBase.h"
0008 #include "FWCore/Framework/interface/global/EDProducerBase.h"
0009 #include "FWCore/Framework/interface/global/EDFilterBase.h"
0010 #include "FWCore/Framework/interface/global/EDAnalyzerBase.h"
0011 #include "FWCore/Framework/interface/global/OutputModuleBase.h"
0012 
0013 #include "FWCore/Framework/interface/stream/EDProducerAdaptorBase.h"
0014 #include "FWCore/Framework/interface/stream/EDFilterAdaptorBase.h"
0015 #include "FWCore/Framework/interface/stream/EDAnalyzerAdaptorBase.h"
0016 
0017 #include "FWCore/Framework/interface/limited/EDProducerBase.h"
0018 #include "FWCore/Framework/interface/limited/EDFilterBase.h"
0019 #include "FWCore/Framework/interface/limited/EDAnalyzerBase.h"
0020 #include "FWCore/Framework/interface/limited/OutputModuleBase.h"
0021 
0022 #include <type_traits>
0023 
0024 namespace edm {
0025   namespace workerimpl {
0026     template <typename T>
0027     struct has_stream_functions {
0028       static bool constexpr value = false;
0029     };
0030 
0031     template <>
0032     struct has_stream_functions<edm::global::EDProducerBase> {
0033       static bool constexpr value = true;
0034     };
0035 
0036     template <>
0037     struct has_stream_functions<edm::global::EDFilterBase> {
0038       static bool constexpr value = true;
0039     };
0040 
0041     template <>
0042     struct has_stream_functions<edm::global::EDAnalyzerBase> {
0043       static bool constexpr value = true;
0044     };
0045 
0046     template <>
0047     struct has_stream_functions<edm::limited::EDProducerBase> {
0048       static bool constexpr value = true;
0049     };
0050 
0051     template <>
0052     struct has_stream_functions<edm::limited::EDFilterBase> {
0053       static bool constexpr value = true;
0054     };
0055 
0056     template <>
0057     struct has_stream_functions<edm::limited::EDAnalyzerBase> {
0058       static bool constexpr value = true;
0059     };
0060 
0061     template <>
0062     struct has_stream_functions<edm::stream::EDProducerAdaptorBase> {
0063       static bool constexpr value = true;
0064     };
0065 
0066     template <>
0067     struct has_stream_functions<edm::stream::EDFilterAdaptorBase> {
0068       static bool constexpr value = true;
0069     };
0070 
0071     template <>
0072     struct has_stream_functions<edm::stream::EDAnalyzerAdaptorBase> {
0073       static bool constexpr value = true;
0074     };
0075 
0076     template <typename T>
0077     struct has_only_stream_transition_functions {
0078       static bool constexpr value = false;
0079     };
0080 
0081     template <>
0082     struct has_only_stream_transition_functions<edm::global::OutputModuleBase> {
0083       static bool constexpr value = true;
0084     };
0085 
0086     struct DoNothing {
0087       template <typename... T>
0088       inline void operator()(const T&...) {}
0089     };
0090 
0091     template <typename T>
0092     struct DoBeginStream {
0093       inline void operator()(WorkerT<T>* iWorker, StreamID id) { iWorker->callWorkerBeginStream(0, id); }
0094     };
0095 
0096     template <typename T>
0097     struct DoEndStream {
0098       inline void operator()(WorkerT<T>* iWorker, StreamID id) { iWorker->callWorkerEndStream(0, id); }
0099     };
0100 
0101     template <typename T, typename INFOTYPE>
0102     struct DoStreamBeginTrans {
0103       inline void operator()(WorkerT<T>* iWorker, StreamID id, INFOTYPE const& info, ModuleCallingContext const* mcc) {
0104         iWorker->callWorkerStreamBegin(0, id, info, mcc);
0105       }
0106     };
0107 
0108     template <typename T, typename INFOTYPE>
0109     struct DoStreamEndTrans {
0110       inline void operator()(WorkerT<T>* iWorker, StreamID id, INFOTYPE const& info, ModuleCallingContext const* mcc) {
0111         iWorker->callWorkerStreamEnd(0, id, info, mcc);
0112       }
0113     };
0114   }  // namespace workerimpl
0115 
0116   template <typename T>
0117   inline WorkerT<T>::WorkerT(std::shared_ptr<T> ed, ModuleDescription const& md, ExceptionToActionTable const* actions)
0118       : Worker(md, actions), module_(ed) {
0119     assert(module_ != nullptr);
0120   }
0121 
0122   template <typename T>
0123   WorkerT<T>::~WorkerT() {}
0124 
0125   template <typename T>
0126   bool WorkerT<T>::wantsProcessBlocks() const {
0127     return module_->wantsProcessBlocks();
0128   }
0129 
0130   template <typename T>
0131   bool WorkerT<T>::wantsInputProcessBlocks() const {
0132     return module_->wantsInputProcessBlocks();
0133   }
0134 
0135   template <typename T>
0136   bool WorkerT<T>::wantsGlobalRuns() const {
0137     return module_->wantsGlobalRuns();
0138   }
0139 
0140   template <typename T>
0141   bool WorkerT<T>::wantsGlobalLuminosityBlocks() const {
0142     return module_->wantsGlobalLuminosityBlocks();
0143   }
0144 
0145   template <typename T>
0146   bool WorkerT<T>::wantsStreamRuns() const {
0147     return module_->wantsStreamRuns();
0148   }
0149 
0150   template <typename T>
0151   bool WorkerT<T>::wantsStreamLuminosityBlocks() const {
0152     return module_->wantsStreamLuminosityBlocks();
0153   }
0154 
0155   template <typename T>
0156   SerialTaskQueue* WorkerT<T>::globalRunsQueue() {
0157     return nullptr;
0158   }
0159   template <typename T>
0160   SerialTaskQueue* WorkerT<T>::globalLuminosityBlocksQueue() {
0161     return nullptr;
0162   }
0163 
0164   //one
0165   template <>
0166   SerialTaskQueue* WorkerT<one::EDProducerBase>::globalRunsQueue() {
0167     return module_->globalRunsQueue();
0168   }
0169   template <>
0170   SerialTaskQueue* WorkerT<one::EDProducerBase>::globalLuminosityBlocksQueue() {
0171     return module_->globalLuminosityBlocksQueue();
0172   }
0173   template <>
0174   SerialTaskQueue* WorkerT<one::EDFilterBase>::globalRunsQueue() {
0175     return module_->globalRunsQueue();
0176   }
0177   template <>
0178   SerialTaskQueue* WorkerT<one::EDFilterBase>::globalLuminosityBlocksQueue() {
0179     return module_->globalLuminosityBlocksQueue();
0180   }
0181   template <>
0182   SerialTaskQueue* WorkerT<one::EDAnalyzerBase>::globalRunsQueue() {
0183     return module_->globalRunsQueue();
0184   }
0185   template <>
0186   SerialTaskQueue* WorkerT<one::EDAnalyzerBase>::globalLuminosityBlocksQueue() {
0187     return module_->globalLuminosityBlocksQueue();
0188   }
0189   template <>
0190   SerialTaskQueue* WorkerT<one::OutputModuleBase>::globalRunsQueue() {
0191     return module_->globalRunsQueue();
0192   }
0193   template <>
0194   SerialTaskQueue* WorkerT<one::OutputModuleBase>::globalLuminosityBlocksQueue() {
0195     return module_->globalLuminosityBlocksQueue();
0196   }
0197 
0198   template <typename T>
0199   inline bool WorkerT<T>::implDo(EventTransitionInfo const& info, ModuleCallingContext const* mcc) {
0200     EventPrincipal const& ep = info.principal();
0201     std::shared_ptr<Worker> sentry(this, [&ep](Worker* obj) { obj->postDoEvent(ep); });
0202     return module_->doEvent(info, activityRegistry(), mcc);
0203   }
0204 
0205   template <typename T>
0206   inline void WorkerT<T>::implDoAcquire(EventTransitionInfo const&,
0207                                         ModuleCallingContext const*,
0208                                         WaitingTaskWithArenaHolder&) {}
0209 
0210   template <>
0211   inline void WorkerT<global::EDProducerBase>::implDoAcquire(EventTransitionInfo const& info,
0212                                                              ModuleCallingContext const* mcc,
0213                                                              WaitingTaskWithArenaHolder& holder) {
0214     module_->doAcquire(info, activityRegistry(), mcc, holder);
0215   }
0216 
0217   template <>
0218   inline void WorkerT<global::EDFilterBase>::implDoAcquire(EventTransitionInfo const& info,
0219                                                            ModuleCallingContext const* mcc,
0220                                                            WaitingTaskWithArenaHolder& holder) {
0221     module_->doAcquire(info, activityRegistry(), mcc, holder);
0222   }
0223 
0224   template <>
0225   inline void WorkerT<global::OutputModuleBase>::implDoAcquire(EventTransitionInfo const& info,
0226                                                                ModuleCallingContext const* mcc,
0227                                                                WaitingTaskWithArenaHolder& holder) {
0228     module_->doAcquire(info, activityRegistry(), mcc, holder);
0229   }
0230 
0231   template <>
0232   inline void WorkerT<stream::EDProducerAdaptorBase>::implDoAcquire(EventTransitionInfo const& info,
0233                                                                     ModuleCallingContext const* mcc,
0234                                                                     WaitingTaskWithArenaHolder& holder) {
0235     module_->doAcquire(info, activityRegistry(), mcc, holder);
0236   }
0237 
0238   template <>
0239   inline void WorkerT<stream::EDFilterAdaptorBase>::implDoAcquire(EventTransitionInfo const& info,
0240                                                                   ModuleCallingContext const* mcc,
0241                                                                   WaitingTaskWithArenaHolder& holder) {
0242     module_->doAcquire(info, activityRegistry(), mcc, holder);
0243   }
0244 
0245   template <typename T>
0246   inline void WorkerT<T>::implDoTransformAsync(WaitingTaskHolder iTask,
0247                                                size_t iTransformIndex,
0248                                                EventPrincipal const& iEvent,
0249                                                ParentContext const& iParent,
0250                                                ServiceWeakToken const& weakToken) {
0251     CMS_SA_ALLOW try {
0252       ServiceRegistry::Operate guard(weakToken.lock());
0253 
0254       ModuleCallingContext mcc(
0255           &module_->moduleDescription(), ModuleCallingContext::State::kPrefetching, iParent, nullptr);
0256       module_->doTransformAsync(iTask, iTransformIndex, iEvent, activityRegistry(), &mcc, weakToken);
0257     } catch (...) {
0258       iTask.doneWaiting(std::current_exception());
0259       return;
0260     }
0261     iTask.doneWaiting(std::exception_ptr());
0262   }
0263 
0264   template <>
0265   inline void WorkerT<global::EDAnalyzerBase>::implDoTransformAsync(WaitingTaskHolder task,
0266                                                                     size_t iTransformIndex,
0267                                                                     EventPrincipal const& iEvent,
0268                                                                     ParentContext const& iParent,
0269                                                                     ServiceWeakToken const& weakToken) {}
0270   template <>
0271   inline void WorkerT<global::OutputModuleBase>::implDoTransformAsync(WaitingTaskHolder task,
0272                                                                       size_t iTransformIndex,
0273                                                                       EventPrincipal const& iEvent,
0274                                                                       ParentContext const& iParent,
0275                                                                       ServiceWeakToken const& weakToken) {}
0276   template <>
0277   inline void WorkerT<limited::EDAnalyzerBase>::implDoTransformAsync(WaitingTaskHolder task,
0278                                                                      size_t iTransformIndex,
0279                                                                      EventPrincipal const& iEvent,
0280                                                                      ParentContext const& iParent,
0281                                                                      ServiceWeakToken const& weakToken) {}
0282   template <>
0283   inline void WorkerT<limited::OutputModuleBase>::implDoTransformAsync(WaitingTaskHolder task,
0284                                                                        size_t iTransformIndex,
0285                                                                        EventPrincipal const& iEvent,
0286                                                                        ParentContext const& iParent,
0287                                                                        ServiceWeakToken const& weakToken) {}
0288   template <>
0289   inline void WorkerT<one::EDAnalyzerBase>::implDoTransformAsync(WaitingTaskHolder task,
0290                                                                  size_t iTransformIndex,
0291                                                                  EventPrincipal const& iEvent,
0292                                                                  ParentContext const& iParent,
0293                                                                  ServiceWeakToken const& weakToken) {}
0294   template <>
0295   inline void WorkerT<one::OutputModuleBase>::implDoTransformAsync(WaitingTaskHolder task,
0296                                                                    size_t iTransformIndex,
0297                                                                    EventPrincipal const& iEvent,
0298                                                                    ParentContext const& iParent,
0299                                                                    ServiceWeakToken const& weakToken) {}
0300   template <>
0301   inline void WorkerT<stream::EDAnalyzerAdaptorBase>::implDoTransformAsync(WaitingTaskHolder task,
0302                                                                            size_t iTransformIndex,
0303                                                                            EventPrincipal const& iEvent,
0304                                                                            ParentContext const& iParent,
0305                                                                            ServiceWeakToken const& weakToken) {}
0306 
0307   template <typename T>
0308   inline size_t WorkerT<T>::transformIndex(edm::BranchDescription const&) const {
0309     return -1;
0310   }
0311   template <>
0312   inline size_t WorkerT<global::EDFilterBase>::transformIndex(edm::BranchDescription const& iBranch) const {
0313     return module_->transformIndex_(iBranch);
0314   }
0315   template <>
0316   inline size_t WorkerT<global::EDProducerBase>::transformIndex(edm::BranchDescription const& iBranch) const {
0317     return module_->transformIndex_(iBranch);
0318   }
0319   template <>
0320   inline size_t WorkerT<stream::EDProducerAdaptorBase>::transformIndex(edm::BranchDescription const& iBranch) const {
0321     return module_->transformIndex_(iBranch);
0322   }
0323   template <>
0324   inline size_t WorkerT<limited::EDFilterBase>::transformIndex(edm::BranchDescription const& iBranch) const {
0325     return module_->transformIndex_(iBranch);
0326   }
0327   template <>
0328   inline size_t WorkerT<limited::EDProducerBase>::transformIndex(edm::BranchDescription const& iBranch) const {
0329     return module_->transformIndex_(iBranch);
0330   }
0331   template <>
0332   inline size_t WorkerT<one::EDFilterBase>::transformIndex(edm::BranchDescription const& iBranch) const {
0333     return module_->transformIndex_(iBranch);
0334   }
0335   template <>
0336   inline size_t WorkerT<one::EDProducerBase>::transformIndex(edm::BranchDescription const& iBranch) const {
0337     return module_->transformIndex_(iBranch);
0338   }
0339 
0340   template <typename T>
0341   inline ProductResolverIndex WorkerT<T>::itemToGetForTransform(size_t iTransformIndex) const {
0342     return -1;
0343   }
0344   template <>
0345   inline ProductResolverIndex WorkerT<global::EDFilterBase>::itemToGetForTransform(size_t iTransformIndex) const {
0346     return module_->transformPrefetch_(iTransformIndex);
0347   }
0348   template <>
0349   inline ProductResolverIndex WorkerT<global::EDProducerBase>::itemToGetForTransform(size_t iTransformIndex) const {
0350     return module_->transformPrefetch_(iTransformIndex);
0351   }
0352   template <>
0353   inline ProductResolverIndex WorkerT<stream::EDProducerAdaptorBase>::itemToGetForTransform(
0354       size_t iTransformIndex) const {
0355     return module_->transformPrefetch_(iTransformIndex);
0356   }
0357   template <>
0358   inline ProductResolverIndex WorkerT<limited::EDFilterBase>::itemToGetForTransform(size_t iTransformIndex) const {
0359     return module_->transformPrefetch_(iTransformIndex);
0360   }
0361   template <>
0362   inline ProductResolverIndex WorkerT<limited::EDProducerBase>::itemToGetForTransform(size_t iTransformIndex) const {
0363     return module_->transformPrefetch_(iTransformIndex);
0364   }
0365   template <>
0366   inline ProductResolverIndex WorkerT<one::EDFilterBase>::itemToGetForTransform(size_t iTransformIndex) const {
0367     return module_->transformPrefetch_(iTransformIndex);
0368   }
0369   template <>
0370   inline ProductResolverIndex WorkerT<one::EDProducerBase>::itemToGetForTransform(size_t iTransformIndex) const {
0371     return module_->transformPrefetch_(iTransformIndex);
0372   }
0373 
0374   template <typename T>
0375   inline bool WorkerT<T>::implNeedToRunSelection() const {
0376     return false;
0377   }
0378 
0379   template <typename T>
0380   inline bool WorkerT<T>::implDoPrePrefetchSelection(StreamID id,
0381                                                      EventPrincipal const& ep,
0382                                                      ModuleCallingContext const* mcc) {
0383     return true;
0384   }
0385   template <typename T>
0386   inline void WorkerT<T>::itemsToGetForSelection(std::vector<ProductResolverIndexAndSkipBit>&) const {}
0387 
0388   template <>
0389   inline bool WorkerT<edm::one::OutputModuleBase>::implNeedToRunSelection() const {
0390     return true;
0391   }
0392 
0393   template <>
0394   inline bool WorkerT<edm::one::OutputModuleBase>::implDoPrePrefetchSelection(StreamID id,
0395                                                                               EventPrincipal const& ep,
0396                                                                               ModuleCallingContext const* mcc) {
0397     return module_->prePrefetchSelection(id, ep, mcc);
0398   }
0399   template <>
0400   inline void WorkerT<edm::one::OutputModuleBase>::itemsToGetForSelection(
0401       std::vector<ProductResolverIndexAndSkipBit>& iItems) const {
0402     iItems = module_->productsUsedBySelection();
0403   }
0404 
0405   template <>
0406   inline bool WorkerT<edm::global::OutputModuleBase>::implNeedToRunSelection() const {
0407     return true;
0408   }
0409   template <>
0410   inline bool WorkerT<edm::global::OutputModuleBase>::implDoPrePrefetchSelection(StreamID id,
0411                                                                                  EventPrincipal const& ep,
0412                                                                                  ModuleCallingContext const* mcc) {
0413     return module_->prePrefetchSelection(id, ep, mcc);
0414   }
0415   template <>
0416   inline void WorkerT<edm::global::OutputModuleBase>::itemsToGetForSelection(
0417       std::vector<ProductResolverIndexAndSkipBit>& iItems) const {
0418     iItems = module_->productsUsedBySelection();
0419   }
0420 
0421   template <>
0422   inline bool WorkerT<edm::limited::OutputModuleBase>::implNeedToRunSelection() const {
0423     return true;
0424   }
0425   template <>
0426   inline bool WorkerT<edm::limited::OutputModuleBase>::implDoPrePrefetchSelection(StreamID id,
0427                                                                                   EventPrincipal const& ep,
0428                                                                                   ModuleCallingContext const* mcc) {
0429     return module_->prePrefetchSelection(id, ep, mcc);
0430   }
0431   template <>
0432   inline void WorkerT<edm::limited::OutputModuleBase>::itemsToGetForSelection(
0433       std::vector<ProductResolverIndexAndSkipBit>& iItems) const {
0434     iItems = module_->productsUsedBySelection();
0435   }
0436 
0437   template <typename T>
0438   bool WorkerT<T>::implDoBeginProcessBlock(ProcessBlockPrincipal const& pbp, ModuleCallingContext const* mcc) {
0439     module_->doBeginProcessBlock(pbp, mcc);
0440     return true;
0441   }
0442 
0443   template <typename T>
0444   bool WorkerT<T>::implDoAccessInputProcessBlock(ProcessBlockPrincipal const& pbp, ModuleCallingContext const* mcc) {
0445     module_->doAccessInputProcessBlock(pbp, mcc);
0446     return true;
0447   }
0448 
0449   template <typename T>
0450   bool WorkerT<T>::implDoEndProcessBlock(ProcessBlockPrincipal const& pbp, ModuleCallingContext const* mcc) {
0451     module_->doEndProcessBlock(pbp, mcc);
0452     return true;
0453   }
0454 
0455   template <typename T>
0456   inline bool WorkerT<T>::implDoBegin(RunTransitionInfo const& info, ModuleCallingContext const* mcc) {
0457     module_->doBeginRun(info, mcc);
0458     return true;
0459   }
0460 
0461   template <typename T>
0462   template <typename D>
0463   void WorkerT<T>::callWorkerStreamBegin(D,
0464                                          StreamID id,
0465                                          RunTransitionInfo const& info,
0466                                          ModuleCallingContext const* mcc) {
0467     module_->doStreamBeginRun(id, info, mcc);
0468   }
0469 
0470   template <typename T>
0471   template <typename D>
0472   void WorkerT<T>::callWorkerStreamEnd(D, StreamID id, RunTransitionInfo const& info, ModuleCallingContext const* mcc) {
0473     module_->doStreamEndRun(id, info, mcc);
0474   }
0475 
0476   template <typename T>
0477   inline bool WorkerT<T>::implDoStreamBegin(StreamID id,
0478                                             RunTransitionInfo const& info,
0479                                             ModuleCallingContext const* mcc) {
0480     std::conditional_t<workerimpl::has_stream_functions<T>::value,
0481                        workerimpl::DoStreamBeginTrans<T, RunTransitionInfo const>,
0482                        workerimpl::DoNothing>
0483         might_call;
0484     might_call(this, id, info, mcc);
0485     return true;
0486   }
0487 
0488   template <typename T>
0489   inline bool WorkerT<T>::implDoStreamEnd(StreamID id, RunTransitionInfo const& info, ModuleCallingContext const* mcc) {
0490     std::conditional_t<workerimpl::has_stream_functions<T>::value,
0491                        workerimpl::DoStreamEndTrans<T, RunTransitionInfo const>,
0492                        workerimpl::DoNothing>
0493         might_call;
0494     might_call(this, id, info, mcc);
0495     return true;
0496   }
0497 
0498   template <typename T>
0499   inline bool WorkerT<T>::implDoEnd(RunTransitionInfo const& info, ModuleCallingContext const* mcc) {
0500     module_->doEndRun(info, mcc);
0501     return true;
0502   }
0503 
0504   template <typename T>
0505   inline bool WorkerT<T>::implDoBegin(LumiTransitionInfo const& info, ModuleCallingContext const* mcc) {
0506     module_->doBeginLuminosityBlock(info, mcc);
0507     return true;
0508   }
0509 
0510   template <typename T>
0511   template <typename D>
0512   void WorkerT<T>::callWorkerStreamBegin(D,
0513                                          StreamID id,
0514                                          LumiTransitionInfo const& info,
0515                                          ModuleCallingContext const* mcc) {
0516     module_->doStreamBeginLuminosityBlock(id, info, mcc);
0517   }
0518 
0519   template <typename T>
0520   template <typename D>
0521   void WorkerT<T>::callWorkerStreamEnd(D, StreamID id, LumiTransitionInfo const& info, ModuleCallingContext const* mcc) {
0522     module_->doStreamEndLuminosityBlock(id, info, mcc);
0523   }
0524 
0525   template <typename T>
0526   inline bool WorkerT<T>::implDoStreamBegin(StreamID id,
0527                                             LumiTransitionInfo const& info,
0528                                             ModuleCallingContext const* mcc) {
0529     std::conditional_t<workerimpl::has_stream_functions<T>::value,
0530                        workerimpl::DoStreamBeginTrans<T, LumiTransitionInfo>,
0531                        workerimpl::DoNothing>
0532         might_call;
0533     might_call(this, id, info, mcc);
0534     return true;
0535   }
0536 
0537   template <typename T>
0538   inline bool WorkerT<T>::implDoStreamEnd(StreamID id,
0539                                           LumiTransitionInfo const& info,
0540                                           ModuleCallingContext const* mcc) {
0541     std::conditional_t<workerimpl::has_stream_functions<T>::value,
0542                        workerimpl::DoStreamEndTrans<T, LumiTransitionInfo>,
0543                        workerimpl::DoNothing>
0544         might_call;
0545     might_call(this, id, info, mcc);
0546 
0547     return true;
0548   }
0549 
0550   template <typename T>
0551   inline bool WorkerT<T>::implDoEnd(LumiTransitionInfo const& info, ModuleCallingContext const* mcc) {
0552     module_->doEndLuminosityBlock(info, mcc);
0553     return true;
0554   }
0555 
0556   template <typename T>
0557   inline std::string WorkerT<T>::workerType() const {
0558     return module_->workerType();
0559   }
0560 
0561   template <typename T>
0562   inline void WorkerT<T>::implBeginJob() {
0563     module_->doBeginJob();
0564   }
0565 
0566   template <typename T>
0567   inline void WorkerT<T>::implEndJob() {
0568     module_->doEndJob();
0569   }
0570 
0571   template <typename T>
0572   template <typename D>
0573   void WorkerT<T>::callWorkerBeginStream(D, StreamID id) {
0574     module_->doBeginStream(id);
0575   }
0576 
0577   template <typename T>
0578   inline void WorkerT<T>::implBeginStream(StreamID id) {
0579     std::conditional_t<workerimpl::has_stream_functions<T>::value or
0580                            workerimpl::has_only_stream_transition_functions<T>::value,
0581                        workerimpl::DoBeginStream<T>,
0582                        workerimpl::DoNothing>
0583         might_call;
0584     might_call(this, id);
0585   }
0586 
0587   template <typename T>
0588   template <typename D>
0589   void WorkerT<T>::callWorkerEndStream(D, StreamID id) {
0590     module_->doEndStream(id);
0591   }
0592 
0593   template <typename T>
0594   inline void WorkerT<T>::implEndStream(StreamID id) {
0595     std::conditional_t<workerimpl::has_stream_functions<T>::value or
0596                            workerimpl::has_only_stream_transition_functions<T>::value,
0597                        workerimpl::DoEndStream<T>,
0598                        workerimpl::DoNothing>
0599         might_call;
0600     might_call(this, id);
0601   }
0602 
0603   template <typename T>
0604   inline void WorkerT<T>::implRespondToOpenInputFile(FileBlock const& fb) {
0605     module_->doRespondToOpenInputFile(fb);
0606   }
0607 
0608   template <typename T>
0609   inline void WorkerT<T>::implRespondToCloseInputFile(FileBlock const& fb) {
0610     module_->doRespondToCloseInputFile(fb);
0611   }
0612 
0613   template <typename T>
0614   void WorkerT<T>::implRespondToCloseOutputFile() {
0615     module_->doRespondToCloseOutputFile();
0616   }
0617 
0618   template <typename T>
0619   inline void WorkerT<T>::implRegisterThinnedAssociations(ProductRegistry const& registry,
0620                                                           ThinnedAssociationsHelper& helper) {
0621     module_->doRegisterThinnedAssociations(registry, helper);
0622   }
0623 
0624   template <typename T>
0625   inline Worker::TaskQueueAdaptor WorkerT<T>::serializeRunModule() {
0626     return Worker::TaskQueueAdaptor{};
0627   }
0628   template <>
0629   Worker::TaskQueueAdaptor WorkerT<one::EDAnalyzerBase>::serializeRunModule() {
0630     return &(module_->sharedResourcesAcquirer().serialQueueChain());
0631   }
0632   template <>
0633   Worker::TaskQueueAdaptor WorkerT<one::EDFilterBase>::serializeRunModule() {
0634     return &(module_->sharedResourcesAcquirer().serialQueueChain());
0635   }
0636   template <>
0637   Worker::TaskQueueAdaptor WorkerT<one::EDProducerBase>::serializeRunModule() {
0638     return &(module_->sharedResourcesAcquirer().serialQueueChain());
0639   }
0640   template <>
0641   Worker::TaskQueueAdaptor WorkerT<one::OutputModuleBase>::serializeRunModule() {
0642     return &(module_->sharedResourcesAcquirer().serialQueueChain());
0643   }
0644   template <>
0645   Worker::TaskQueueAdaptor WorkerT<limited::EDAnalyzerBase>::serializeRunModule() {
0646     return &(module_->queue());
0647   }
0648   template <>
0649   Worker::TaskQueueAdaptor WorkerT<limited::EDFilterBase>::serializeRunModule() {
0650     return &(module_->queue());
0651   }
0652   template <>
0653   Worker::TaskQueueAdaptor WorkerT<limited::EDProducerBase>::serializeRunModule() {
0654     return &(module_->queue());
0655   }
0656   template <>
0657   Worker::TaskQueueAdaptor WorkerT<limited::OutputModuleBase>::serializeRunModule() {
0658     return &(module_->queue());
0659   }
0660 
0661   namespace {
0662     template <typename T>
0663     bool mustPrefetchMayGet();
0664 
0665     template <>
0666     bool mustPrefetchMayGet<edm::one::EDProducerBase>() {
0667       return true;
0668     }
0669     template <>
0670     bool mustPrefetchMayGet<edm::one::EDFilterBase>() {
0671       return true;
0672     }
0673     template <>
0674     bool mustPrefetchMayGet<edm::one::EDAnalyzerBase>() {
0675       return true;
0676     }
0677     template <>
0678     bool mustPrefetchMayGet<edm::one::OutputModuleBase>() {
0679       return true;
0680     }
0681 
0682     template <>
0683     bool mustPrefetchMayGet<edm::global::EDProducerBase>() {
0684       return true;
0685     }
0686     template <>
0687     bool mustPrefetchMayGet<edm::global::EDFilterBase>() {
0688       return true;
0689     }
0690     template <>
0691     bool mustPrefetchMayGet<edm::global::EDAnalyzerBase>() {
0692       return true;
0693     }
0694     template <>
0695     bool mustPrefetchMayGet<edm::global::OutputModuleBase>() {
0696       return true;
0697     }
0698 
0699     template <>
0700     bool mustPrefetchMayGet<edm::limited::EDProducerBase>() {
0701       return true;
0702     }
0703     template <>
0704     bool mustPrefetchMayGet<edm::limited::EDFilterBase>() {
0705       return true;
0706     }
0707     template <>
0708     bool mustPrefetchMayGet<edm::limited::EDAnalyzerBase>() {
0709       return true;
0710     }
0711     template <>
0712     bool mustPrefetchMayGet<edm::limited::OutputModuleBase>() {
0713       return true;
0714     }
0715 
0716     template <>
0717     bool mustPrefetchMayGet<edm::stream::EDProducerAdaptorBase>() {
0718       return true;
0719     }
0720     template <>
0721     bool mustPrefetchMayGet<edm::stream::EDFilterAdaptorBase>() {
0722       return true;
0723     }
0724     template <>
0725     bool mustPrefetchMayGet<edm::stream::EDAnalyzerAdaptorBase>() {
0726       return true;
0727     }
0728 
0729   }  // namespace
0730 
0731   template <typename T>
0732   void WorkerT<T>::updateLookup(BranchType iBranchType, ProductResolverIndexHelper const& iHelper) {
0733     module_->updateLookup(iBranchType, iHelper, mustPrefetchMayGet<T>());
0734   }
0735 
0736   template <typename T>
0737   void WorkerT<T>::updateLookup(eventsetup::ESRecordsToProductResolverIndices const& iPI) {
0738     module_->updateLookup(iPI);
0739   }
0740 
0741   template <typename T>
0742   void WorkerT<T>::selectInputProcessBlocks(ProductRegistry const& productRegistry,
0743                                             ProcessBlockHelperBase const& processBlockHelperBase) {
0744     module_->selectInputProcessBlocks(productRegistry, processBlockHelperBase);
0745   }
0746 
0747   namespace {
0748     using ModuleToResolverIndicies =
0749         std::unordered_multimap<std::string, std::tuple<edm::TypeID const*, const char*, edm::ProductResolverIndex>>;
0750     void resolvePutIndiciesImpl(void*,
0751                                 BranchType iBranchType,
0752                                 ModuleToResolverIndicies const& iIndicies,
0753                                 std::string const& iModuleLabel) {
0754       //Do nothing
0755     }
0756 
0757     void resolvePutIndiciesImpl(ProducerBase* iProd,
0758                                 BranchType iBranchType,
0759                                 ModuleToResolverIndicies const& iIndicies,
0760                                 std::string const& iModuleLabel) {
0761       iProd->resolvePutIndicies(iBranchType, iIndicies, iModuleLabel);
0762     }
0763 
0764     void resolvePutIndiciesImpl(edm::stream::EDProducerAdaptorBase* iProd,
0765                                 BranchType iBranchType,
0766                                 ModuleToResolverIndicies const& iIndicies,
0767                                 std::string const& iModuleLabel) {
0768       iProd->resolvePutIndicies(iBranchType, iIndicies, iModuleLabel);
0769     }
0770     void resolvePutIndiciesImpl(edm::stream::EDFilterAdaptorBase* iProd,
0771                                 BranchType iBranchType,
0772                                 ModuleToResolverIndicies const& iIndicies,
0773                                 std::string const& iModuleLabel) {
0774       iProd->resolvePutIndicies(iBranchType, iIndicies, iModuleLabel);
0775     }
0776 
0777   }  // namespace
0778 
0779   template <typename T>
0780   void WorkerT<T>::resolvePutIndicies(
0781       BranchType iBranchType,
0782       std::unordered_multimap<std::string, std::tuple<TypeID const*, const char*, edm::ProductResolverIndex>> const&
0783           iIndicies) {
0784     resolvePutIndiciesImpl(&module(), iBranchType, iIndicies, description()->moduleLabel());
0785   }
0786 
0787   template <>
0788   Worker::Types WorkerT<edm::one::EDProducerBase>::moduleType() const {
0789     return Worker::kProducer;
0790   }
0791   template <>
0792   Worker::Types WorkerT<edm::one::EDFilterBase>::moduleType() const {
0793     return Worker::kFilter;
0794   }
0795   template <>
0796   Worker::Types WorkerT<edm::one::EDAnalyzerBase>::moduleType() const {
0797     return Worker::kAnalyzer;
0798   }
0799   template <>
0800   Worker::Types WorkerT<edm::one::OutputModuleBase>::moduleType() const {
0801     return Worker::kOutputModule;
0802   }
0803 
0804   template <>
0805   Worker::Types WorkerT<edm::global::EDProducerBase>::moduleType() const {
0806     return Worker::kProducer;
0807   }
0808   template <>
0809   Worker::Types WorkerT<edm::global::EDFilterBase>::moduleType() const {
0810     return Worker::kFilter;
0811   }
0812   template <>
0813   Worker::Types WorkerT<edm::global::EDAnalyzerBase>::moduleType() const {
0814     return Worker::kAnalyzer;
0815   }
0816   template <>
0817   Worker::Types WorkerT<edm::global::OutputModuleBase>::moduleType() const {
0818     return Worker::kOutputModule;
0819   }
0820 
0821   template <>
0822   Worker::Types WorkerT<edm::limited::EDProducerBase>::moduleType() const {
0823     return Worker::kProducer;
0824   }
0825   template <>
0826   Worker::Types WorkerT<edm::limited::EDFilterBase>::moduleType() const {
0827     return Worker::kFilter;
0828   }
0829   template <>
0830   Worker::Types WorkerT<edm::limited::EDAnalyzerBase>::moduleType() const {
0831     return Worker::kAnalyzer;
0832   }
0833   template <>
0834   Worker::Types WorkerT<edm::limited::OutputModuleBase>::moduleType() const {
0835     return Worker::kOutputModule;
0836   }
0837 
0838   template <>
0839   Worker::Types WorkerT<edm::stream::EDProducerAdaptorBase>::moduleType() const {
0840     return Worker::kProducer;
0841   }
0842   template <>
0843   Worker::Types WorkerT<edm::stream::EDFilterAdaptorBase>::moduleType() const {
0844     return Worker::kFilter;
0845   }
0846   template <>
0847   Worker::Types WorkerT<edm::stream::EDAnalyzerAdaptorBase>::moduleType() const {
0848     return Worker::kAnalyzer;
0849   }
0850 
0851   template <>
0852   Worker::ConcurrencyTypes WorkerT<edm::one::EDProducerBase>::moduleConcurrencyType() const {
0853     return Worker::kOne;
0854   }
0855   template <>
0856   Worker::ConcurrencyTypes WorkerT<edm::one::EDFilterBase>::moduleConcurrencyType() const {
0857     return Worker::kOne;
0858   }
0859   template <>
0860   Worker::ConcurrencyTypes WorkerT<edm::one::EDAnalyzerBase>::moduleConcurrencyType() const {
0861     return Worker::kOne;
0862   }
0863   template <>
0864   Worker::ConcurrencyTypes WorkerT<edm::one::OutputModuleBase>::moduleConcurrencyType() const {
0865     return Worker::kOne;
0866   }
0867 
0868   template <>
0869   Worker::ConcurrencyTypes WorkerT<edm::global::EDProducerBase>::moduleConcurrencyType() const {
0870     return Worker::kGlobal;
0871   }
0872   template <>
0873   Worker::ConcurrencyTypes WorkerT<edm::global::EDFilterBase>::moduleConcurrencyType() const {
0874     return Worker::kGlobal;
0875   }
0876   template <>
0877   Worker::ConcurrencyTypes WorkerT<edm::global::EDAnalyzerBase>::moduleConcurrencyType() const {
0878     return Worker::kGlobal;
0879   }
0880   template <>
0881   Worker::ConcurrencyTypes WorkerT<edm::global::OutputModuleBase>::moduleConcurrencyType() const {
0882     return Worker::kGlobal;
0883   }
0884 
0885   template <>
0886   Worker::ConcurrencyTypes WorkerT<edm::limited::EDProducerBase>::moduleConcurrencyType() const {
0887     return Worker::kLimited;
0888   }
0889   template <>
0890   Worker::ConcurrencyTypes WorkerT<edm::limited::EDFilterBase>::moduleConcurrencyType() const {
0891     return Worker::kLimited;
0892   }
0893   template <>
0894   Worker::ConcurrencyTypes WorkerT<edm::limited::EDAnalyzerBase>::moduleConcurrencyType() const {
0895     return Worker::kLimited;
0896   }
0897   template <>
0898   Worker::ConcurrencyTypes WorkerT<edm::limited::OutputModuleBase>::moduleConcurrencyType() const {
0899     return Worker::kLimited;
0900   }
0901 
0902   template <>
0903   Worker::ConcurrencyTypes WorkerT<edm::stream::EDProducerAdaptorBase>::moduleConcurrencyType() const {
0904     return Worker::kStream;
0905   }
0906   template <>
0907   Worker::ConcurrencyTypes WorkerT<edm::stream::EDFilterAdaptorBase>::moduleConcurrencyType() const {
0908     return Worker::kStream;
0909   }
0910   template <>
0911   Worker::ConcurrencyTypes WorkerT<edm::stream::EDAnalyzerAdaptorBase>::moduleConcurrencyType() const {
0912     return Worker::kStream;
0913   }
0914 
0915   //Explicitly instantiate our needed templates to avoid having the compiler
0916   // instantiate them in all of our libraries
0917   template class WorkerT<one::EDProducerBase>;
0918   template class WorkerT<one::EDFilterBase>;
0919   template class WorkerT<one::EDAnalyzerBase>;
0920   template class WorkerT<one::OutputModuleBase>;
0921   template class WorkerT<global::EDProducerBase>;
0922   template class WorkerT<global::EDFilterBase>;
0923   template class WorkerT<global::EDAnalyzerBase>;
0924   template class WorkerT<global::OutputModuleBase>;
0925   template class WorkerT<stream::EDProducerAdaptorBase>;
0926   template class WorkerT<stream::EDFilterAdaptorBase>;
0927   template class WorkerT<stream::EDAnalyzerAdaptorBase>;
0928   template class WorkerT<limited::EDProducerBase>;
0929   template class WorkerT<limited::EDFilterBase>;
0930   template class WorkerT<limited::EDAnalyzerBase>;
0931   template class WorkerT<limited::OutputModuleBase>;
0932 }  // namespace edm
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!