CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
WorkerT.cc
Go to the documentation of this file.
3 
15 
19 
24 
25 #include <type_traits>
26 
27 namespace edm {
28  namespace workerimpl {
29  template <typename T>
31  static bool constexpr value = false;
32  };
33 
34  template <>
36  static bool constexpr value = true;
37  };
38 
39  template <>
41  static bool constexpr value = true;
42  };
43 
44  template <>
46  static bool constexpr value = true;
47  };
48 
49  template <>
51  static bool constexpr value = true;
52  };
53 
54  template <>
56  static bool constexpr value = true;
57  };
58 
59  template <>
61  static bool constexpr value = true;
62  };
63 
64  template <>
66  static bool constexpr value = true;
67  };
68 
69  template <>
71  static bool constexpr value = true;
72  };
73 
74  template <>
76  static bool constexpr value = true;
77  };
78 
79  template <typename T>
81  static bool constexpr value = false;
82  };
83 
84  template <>
86  static bool constexpr value = true;
87  };
88 
89  struct DoNothing {
90  template <typename... T>
91  inline void operator()(const T&...) {}
92  };
93 
94  template <typename T>
95  struct DoBeginStream {
96  inline void operator()(WorkerT<T>* iWorker, StreamID id) { iWorker->callWorkerBeginStream(0, id); }
97  };
98 
99  template <typename T>
100  struct DoEndStream {
101  inline void operator()(WorkerT<T>* iWorker, StreamID id) { iWorker->callWorkerEndStream(0, id); }
102  };
103 
104  template <typename T, typename INFOTYPE>
106  inline void operator()(WorkerT<T>* iWorker, StreamID id, INFOTYPE const& info, ModuleCallingContext const* mcc) {
107  iWorker->callWorkerStreamBegin(0, id, info, mcc);
108  }
109  };
110 
111  template <typename T, typename INFOTYPE>
113  inline void operator()(WorkerT<T>* iWorker, StreamID id, INFOTYPE const& info, ModuleCallingContext const* mcc) {
114  iWorker->callWorkerStreamEnd(0, id, info, mcc);
115  }
116  };
117  } // namespace workerimpl
118 
119  template <typename T>
120  inline WorkerT<T>::WorkerT(std::shared_ptr<T> ed, ModuleDescription const& md, ExceptionToActionTable const* actions)
121  : Worker(md, actions), module_(ed) {
122  assert(module_ != nullptr);
123  }
124 
125  template <typename T>
127 
128  template <typename T>
130  return module_->wantsProcessBlocks();
131  }
132 
133  template <typename T>
135  return module_->wantsInputProcessBlocks();
136  }
137 
138  template <typename T>
140  return module_->wantsGlobalRuns();
141  }
142 
143  template <typename T>
145  return module_->wantsGlobalLuminosityBlocks();
146  }
147 
148  template <typename T>
150  return module_->wantsStreamRuns();
151  }
152 
153  template <typename T>
155  return module_->wantsStreamLuminosityBlocks();
156  }
157 
158  template <typename T>
160  return nullptr;
161  }
162  template <typename T>
164  return nullptr;
165  }
166  template <>
168  return module_->globalRunsQueue();
169  }
170  template <>
172  return module_->globalLuminosityBlocksQueue();
173  }
174  template <>
176  return module_->globalRunsQueue();
177  }
178  template <>
180  return module_->globalLuminosityBlocksQueue();
181  }
182  template <>
184  return module_->globalRunsQueue();
185  }
186  template <>
188  return module_->globalLuminosityBlocksQueue();
189  }
190  //one
191  template <>
193  return module_->globalRunsQueue();
194  }
195  template <>
197  return module_->globalLuminosityBlocksQueue();
198  }
199  template <>
201  return module_->globalRunsQueue();
202  }
203  template <>
205  return module_->globalLuminosityBlocksQueue();
206  }
207  template <>
209  return module_->globalRunsQueue();
210  }
211  template <>
213  return module_->globalLuminosityBlocksQueue();
214  }
215  template <>
217  return module_->globalRunsQueue();
218  }
219  template <>
221  return module_->globalLuminosityBlocksQueue();
222  }
223 
224  template <typename T>
226  EventPrincipal const& ep = info.principal();
227  std::shared_ptr<Worker> sentry(this, [&ep](Worker* obj) { obj->postDoEvent(ep); });
228  return module_->doEvent(info, activityRegistry(), mcc);
229  }
230 
231  template <typename T>
233  ModuleCallingContext const*,
235 
236  template <>
238  ModuleCallingContext const* mcc,
239  WaitingTaskWithArenaHolder& holder) {
240  module_->doAcquire(info, activityRegistry(), mcc, holder);
241  }
242 
243  template <>
245  ModuleCallingContext const* mcc,
246  WaitingTaskWithArenaHolder& holder) {
247  module_->doAcquire(info, activityRegistry(), mcc, holder);
248  }
249 
250  template <>
252  ModuleCallingContext const* mcc,
253  WaitingTaskWithArenaHolder& holder) {
254  module_->doAcquire(info, activityRegistry(), mcc, holder);
255  }
256 
257  template <>
259  ModuleCallingContext const* mcc,
260  WaitingTaskWithArenaHolder& holder) {
261  module_->doAcquire(info, activityRegistry(), mcc, holder);
262  }
263 
264  template <>
266  ModuleCallingContext const* mcc,
267  WaitingTaskWithArenaHolder& holder) {
268  module_->doAcquire(info, activityRegistry(), mcc, holder);
269  }
270 
271  template <typename T>
273  size_t iTransformIndex,
274  EventPrincipal const& iEvent,
275  ParentContext const& iParent,
276  ServiceWeakToken const& weakToken) {
277  CMS_SA_ALLOW try {
278  ServiceRegistry::Operate guard(weakToken.lock());
279 
281  &module_->moduleDescription(), ModuleCallingContext::State::kPrefetching, iParent, nullptr);
282  module_->doTransformAsync(iTask, iTransformIndex, iEvent, activityRegistry(), &mcc, weakToken);
283  } catch (...) {
284  iTask.doneWaiting(std::current_exception());
285  return;
286  }
287  iTask.doneWaiting(std::exception_ptr());
288  }
289 
290  template <>
292  size_t iTransformIndex,
293  EventPrincipal const& iEvent,
294  ParentContext const& iParent,
295  ServiceWeakToken const& weakToken) {}
296  template <>
298  size_t iTransformIndex,
299  EventPrincipal const& iEvent,
300  ParentContext const& iParent,
301  ServiceWeakToken const& weakToken) {}
302  template <>
304  size_t iTransformIndex,
305  EventPrincipal const& iEvent,
306  ParentContext const& iParent,
307  ServiceWeakToken const& weakToken) {}
308  template <>
310  size_t iTransformIndex,
311  EventPrincipal const& iEvent,
312  ParentContext const& iParent,
313  ServiceWeakToken const& weakToken) {}
314  template <>
316  size_t iTransformIndex,
317  EventPrincipal const& iEvent,
318  ParentContext const& iParent,
319  ServiceWeakToken const& weakToken) {}
320  template <>
322  size_t iTransformIndex,
323  EventPrincipal const& iEvent,
324  ParentContext const& iParent,
325  ServiceWeakToken const& weakToken) {}
326  template <>
328  size_t iTransformIndex,
329  EventPrincipal const& iEvent,
330  ParentContext const& iParent,
331  ServiceWeakToken const& weakToken) {}
332  template <>
334  size_t iTransformIndex,
335  EventPrincipal const& iEvent,
336  ParentContext const& iParent,
337  ServiceWeakToken const& weakToken) {}
338  template <>
340  size_t iTransformIndex,
341  EventPrincipal const& iEvent,
342  ParentContext const& iParent,
343  ServiceWeakToken const& weakToken) {}
344  template <>
346  size_t iTransformIndex,
347  EventPrincipal const& iEvent,
348  ParentContext const& iParent,
349  ServiceWeakToken const& weakToken) {}
350 
351  template <typename T>
353  return -1;
354  }
355  template <>
357  return module_->transformIndex_(iBranch);
358  }
359  template <>
361  return module_->transformIndex_(iBranch);
362  }
363  template <>
365  return module_->transformIndex_(iBranch);
366  }
367  template <>
369  return module_->transformIndex_(iBranch);
370  }
371  template <>
373  return module_->transformIndex_(iBranch);
374  }
375  template <>
377  return module_->transformIndex_(iBranch);
378  }
379  template <>
381  return module_->transformIndex_(iBranch);
382  }
383 
384  template <typename T>
385  inline ProductResolverIndex WorkerT<T>::itemToGetForTransform(size_t iTransformIndex) const {
386  return -1;
387  }
388  template <>
390  return module_->transformPrefetch_(iTransformIndex);
391  }
392  template <>
394  return module_->transformPrefetch_(iTransformIndex);
395  }
396  template <>
398  size_t iTransformIndex) const {
399  return module_->transformPrefetch_(iTransformIndex);
400  }
401  template <>
403  return module_->transformPrefetch_(iTransformIndex);
404  }
405  template <>
407  return module_->transformPrefetch_(iTransformIndex);
408  }
409  template <>
411  return module_->transformPrefetch_(iTransformIndex);
412  }
413  template <>
415  return module_->transformPrefetch_(iTransformIndex);
416  }
417 
418  template <typename T>
420  return false;
421  }
422 
423  template <typename T>
425  EventPrincipal const& ep,
426  ModuleCallingContext const* mcc) {
427  return true;
428  }
429  template <typename T>
430  inline void WorkerT<T>::itemsToGetForSelection(std::vector<ProductResolverIndexAndSkipBit>&) const {}
431 
432  template <>
434  return true;
435  }
436 
437  template <>
439  EventPrincipal const& ep,
440  ModuleCallingContext const* mcc) {
441  return module_->prePrefetchSelection(id, ep, mcc);
442  }
443  template <>
445  std::vector<ProductResolverIndexAndSkipBit>& iItems) const {
446  iItems = module_->productsUsedBySelection();
447  }
448 
449  template <>
451  return true;
452  }
453  template <>
455  EventPrincipal const& ep,
456  ModuleCallingContext const* mcc) {
457  return module_->prePrefetchSelection(id, ep, mcc);
458  }
459  template <>
461  std::vector<ProductResolverIndexAndSkipBit>& iItems) const {
462  iItems = module_->productsUsedBySelection();
463  }
464 
465  template <>
467  return true;
468  }
469  template <>
471  EventPrincipal const& ep,
472  ModuleCallingContext const* mcc) {
473  return module_->prePrefetchSelection(id, ep, mcc);
474  }
475  template <>
477  std::vector<ProductResolverIndexAndSkipBit>& iItems) const {
478  iItems = module_->productsUsedBySelection();
479  }
480 
481  template <typename T>
483  module_->doBeginProcessBlock(pbp, mcc);
484  return true;
485  }
486 
487  template <typename T>
489  module_->doAccessInputProcessBlock(pbp, mcc);
490  return true;
491  }
492 
493  template <typename T>
495  module_->doEndProcessBlock(pbp, mcc);
496  return true;
497  }
498 
499  template <typename T>
501  module_->doBeginRun(info, mcc);
502  return true;
503  }
504 
505  template <typename T>
506  template <typename D>
508  StreamID id,
509  RunTransitionInfo const& info,
510  ModuleCallingContext const* mcc) {
511  module_->doStreamBeginRun(id, info, mcc);
512  }
513 
514  template <typename T>
515  template <typename D>
517  module_->doStreamEndRun(id, info, mcc);
518  }
519 
520  template <typename T>
522  RunTransitionInfo const& info,
523  ModuleCallingContext const* mcc) {
527  might_call;
528  might_call(this, id, info, mcc);
529  return true;
530  }
531 
532  template <typename T>
537  might_call;
538  might_call(this, id, info, mcc);
539  return true;
540  }
541 
542  template <typename T>
544  module_->doEndRun(info, mcc);
545  return true;
546  }
547 
548  template <typename T>
550  module_->doBeginLuminosityBlock(info, mcc);
551  return true;
552  }
553 
554  template <typename T>
555  template <typename D>
557  StreamID id,
558  LumiTransitionInfo const& info,
559  ModuleCallingContext const* mcc) {
560  module_->doStreamBeginLuminosityBlock(id, info, mcc);
561  }
562 
563  template <typename T>
564  template <typename D>
566  module_->doStreamEndLuminosityBlock(id, info, mcc);
567  }
568 
569  template <typename T>
571  LumiTransitionInfo const& info,
572  ModuleCallingContext const* mcc) {
576  might_call;
577  might_call(this, id, info, mcc);
578  return true;
579  }
580 
581  template <typename T>
583  LumiTransitionInfo const& info,
584  ModuleCallingContext const* mcc) {
588  might_call;
589  might_call(this, id, info, mcc);
590 
591  return true;
592  }
593 
594  template <typename T>
596  module_->doEndLuminosityBlock(info, mcc);
597  return true;
598  }
599 
600  template <typename T>
602  return module_->workerType();
603  }
604 
605  template <typename T>
606  inline void WorkerT<T>::implBeginJob() {
607  module_->doBeginJob();
608  }
609 
610  template <typename T>
611  inline void WorkerT<T>::implEndJob() {
612  module_->doEndJob();
613  }
614 
615  template <typename T>
616  template <typename D>
618  module_->doBeginStream(id);
619  }
620 
621  template <typename T>
627  might_call;
628  might_call(this, id);
629  }
630 
631  template <typename T>
632  template <typename D>
634  module_->doEndStream(id);
635  }
636 
637  template <typename T>
643  might_call;
644  might_call(this, id);
645  }
646 
647  template <typename T>
649  module_->doRespondToOpenInputFile(fb);
650  }
651 
652  template <typename T>
654  module_->doRespondToCloseInputFile(fb);
655  }
656 
657  template <typename T>
659  module_->doRespondToCloseOutputFile();
660  }
661 
662  template <typename T>
665  module_->doRegisterThinnedAssociations(registry, helper);
666  }
667 
668  template <typename T>
670  return Worker::TaskQueueAdaptor{};
671  }
672  template <>
674  return &(module_->sharedResourcesAcquirer().serialQueueChain());
675  }
676  template <>
678  return &(module_->sharedResourcesAcquirer().serialQueueChain());
679  }
680  template <>
682  return &(module_->sharedResourcesAcquirer().serialQueueChain());
683  }
684  template <>
686  return &(module_->sharedResourcesAcquirer().serialQueueChain());
687  }
688  template <>
690  return &(module_->sharedResourcesAcquirer().serialQueueChain());
691  }
692  template <>
694  return &(module_->sharedResourcesAcquirer().serialQueueChain());
695  }
696  template <>
698  return &(module_->sharedResourcesAcquirer().serialQueueChain());
699  }
700  template <>
702  return &(module_->queue());
703  }
704  template <>
706  return &(module_->queue());
707  }
708  template <>
710  return &(module_->queue());
711  }
712  template <>
714  return &(module_->queue());
715  }
716 
717  namespace {
718  template <typename T>
719  bool mustPrefetchMayGet();
720 
721  template <>
722  bool mustPrefetchMayGet<EDAnalyzer>() {
723  return true;
724  }
725  template <>
726  bool mustPrefetchMayGet<EDProducer>() {
727  return true;
728  }
729  template <>
730  bool mustPrefetchMayGet<EDFilter>() {
731  return true;
732  }
733 
734  template <>
735  bool mustPrefetchMayGet<edm::one::EDProducerBase>() {
736  return true;
737  }
738  template <>
739  bool mustPrefetchMayGet<edm::one::EDFilterBase>() {
740  return true;
741  }
742  template <>
743  bool mustPrefetchMayGet<edm::one::EDAnalyzerBase>() {
744  return true;
745  }
746  template <>
747  bool mustPrefetchMayGet<edm::one::OutputModuleBase>() {
748  return true;
749  }
750 
751  template <>
752  bool mustPrefetchMayGet<edm::global::EDProducerBase>() {
753  return true;
754  }
755  template <>
756  bool mustPrefetchMayGet<edm::global::EDFilterBase>() {
757  return true;
758  }
759  template <>
760  bool mustPrefetchMayGet<edm::global::EDAnalyzerBase>() {
761  return true;
762  }
763  template <>
764  bool mustPrefetchMayGet<edm::global::OutputModuleBase>() {
765  return true;
766  }
767 
768  template <>
769  bool mustPrefetchMayGet<edm::limited::EDProducerBase>() {
770  return true;
771  }
772  template <>
773  bool mustPrefetchMayGet<edm::limited::EDFilterBase>() {
774  return true;
775  }
776  template <>
777  bool mustPrefetchMayGet<edm::limited::EDAnalyzerBase>() {
778  return true;
779  }
780  template <>
781  bool mustPrefetchMayGet<edm::limited::OutputModuleBase>() {
782  return true;
783  }
784 
785  template <>
786  bool mustPrefetchMayGet<edm::stream::EDProducerAdaptorBase>() {
787  return true;
788  }
789  template <>
790  bool mustPrefetchMayGet<edm::stream::EDFilterAdaptorBase>() {
791  return true;
792  }
793  template <>
794  bool mustPrefetchMayGet<edm::stream::EDAnalyzerAdaptorBase>() {
795  return true;
796  }
797 
798  } // namespace
799 
800  template <typename T>
802  module_->updateLookup(iBranchType, iHelper, mustPrefetchMayGet<T>());
803  }
804 
805  template <typename T>
807  module_->updateLookup(iPI);
808  }
809 
810  template <typename T>
812  ProcessBlockHelperBase const& processBlockHelperBase) {
813  module_->selectInputProcessBlocks(productRegistry, processBlockHelperBase);
814  }
815 
816  namespace {
817  using ModuleToResolverIndicies =
818  std::unordered_multimap<std::string, std::tuple<edm::TypeID const*, const char*, edm::ProductResolverIndex>>;
819  void resolvePutIndiciesImpl(void*,
820  BranchType iBranchType,
821  ModuleToResolverIndicies const& iIndicies,
822  std::string const& iModuleLabel) {
823  //Do nothing
824  }
825 
826  void resolvePutIndiciesImpl(ProducerBase* iProd,
827  BranchType iBranchType,
828  ModuleToResolverIndicies const& iIndicies,
829  std::string const& iModuleLabel) {
830  iProd->resolvePutIndicies(iBranchType, iIndicies, iModuleLabel);
831  }
832 
833  void resolvePutIndiciesImpl(edm::stream::EDProducerAdaptorBase* iProd,
834  BranchType iBranchType,
835  ModuleToResolverIndicies const& iIndicies,
836  std::string const& iModuleLabel) {
837  iProd->resolvePutIndicies(iBranchType, iIndicies, iModuleLabel);
838  }
839  void resolvePutIndiciesImpl(edm::stream::EDFilterAdaptorBase* iProd,
840  BranchType iBranchType,
841  ModuleToResolverIndicies const& iIndicies,
842  std::string const& iModuleLabel) {
843  iProd->resolvePutIndicies(iBranchType, iIndicies, iModuleLabel);
844  }
845 
846  } // namespace
847 
848  template <typename T>
850  BranchType iBranchType,
851  std::unordered_multimap<std::string, std::tuple<TypeID const*, const char*, edm::ProductResolverIndex>> const&
852  iIndicies) {
853  resolvePutIndiciesImpl(&module(), iBranchType, iIndicies, description()->moduleLabel());
854  }
855 
856  template <>
858  return Worker::kAnalyzer;
859  }
860  template <>
862  return Worker::kProducer;
863  }
864  template <>
866  return Worker::kFilter;
867  }
868  template <>
870  return Worker::kProducer;
871  }
872  template <>
874  return Worker::kFilter;
875  }
876  template <>
878  return Worker::kAnalyzer;
879  }
880  template <>
882  return Worker::kOutputModule;
883  }
884 
885  template <>
887  return Worker::kProducer;
888  }
889  template <>
891  return Worker::kFilter;
892  }
893  template <>
895  return Worker::kAnalyzer;
896  }
897  template <>
899  return Worker::kOutputModule;
900  }
901 
902  template <>
904  return Worker::kProducer;
905  }
906  template <>
908  return Worker::kFilter;
909  }
910  template <>
912  return Worker::kAnalyzer;
913  }
914  template <>
916  return Worker::kOutputModule;
917  }
918 
919  template <>
921  return Worker::kProducer;
922  }
923  template <>
925  return Worker::kFilter;
926  }
927  template <>
929  return Worker::kAnalyzer;
930  }
931 
932  template <>
934  return Worker::kLegacy;
935  }
936  template <>
938  return Worker::kLegacy;
939  }
940  template <>
942  return Worker::kLegacy;
943  }
944  template <>
946  return Worker::kOne;
947  }
948  template <>
950  return Worker::kOne;
951  }
952  template <>
954  return Worker::kOne;
955  }
956  template <>
958  return Worker::kOne;
959  }
960 
961  template <>
963  return Worker::kGlobal;
964  }
965  template <>
967  return Worker::kGlobal;
968  }
969  template <>
971  return Worker::kGlobal;
972  }
973  template <>
975  return Worker::kGlobal;
976  }
977 
978  template <>
980  return Worker::kLimited;
981  }
982  template <>
984  return Worker::kLimited;
985  }
986  template <>
988  return Worker::kLimited;
989  }
990  template <>
992  return Worker::kLimited;
993  }
994 
995  template <>
997  return Worker::kStream;
998  }
999  template <>
1001  return Worker::kStream;
1002  }
1003  template <>
1005  return Worker::kStream;
1006  }
1007 
1008  //Explicitly instantiate our needed templates to avoid having the compiler
1009  // instantiate them in all of our libraries
1010  template class WorkerT<EDProducer>;
1011  template class WorkerT<EDFilter>;
1012  template class WorkerT<EDAnalyzer>;
1013  template class WorkerT<one::EDProducerBase>;
1014  template class WorkerT<one::EDFilterBase>;
1015  template class WorkerT<one::EDAnalyzerBase>;
1016  template class WorkerT<one::OutputModuleBase>;
1017  template class WorkerT<global::EDProducerBase>;
1018  template class WorkerT<global::EDFilterBase>;
1019  template class WorkerT<global::EDAnalyzerBase>;
1020  template class WorkerT<global::OutputModuleBase>;
1022  template class WorkerT<stream::EDFilterAdaptorBase>;
1024  template class WorkerT<limited::EDProducerBase>;
1025  template class WorkerT<limited::EDFilterBase>;
1026  template class WorkerT<limited::EDAnalyzerBase>;
1027  template class WorkerT<limited::OutputModuleBase>;
1028 } // namespace edm
void updateLookup(BranchType iBranchType, ProductResolverIndexHelper const &) final
Definition: WorkerT.cc:801
static const char module_[]
void operator()(WorkerT< T > *iWorker, StreamID id, INFOTYPE const &info, ModuleCallingContext const *mcc)
Definition: WorkerT.cc:113
static const TGPicture * info(bool iBackgroundIsBlack)
#define CMS_SA_ALLOW
bool implDoEndProcessBlock(ProcessBlockPrincipal const &, ModuleCallingContext const *) override
Definition: WorkerT.cc:494
SerialTaskQueue * globalRunsQueue() final
Definition: WorkerT.cc:159
Definition: helper.py:1
roAction_t actions[nactions]
Definition: GenABIO.cc:181
unsigned int ProductResolverIndex
SerialTaskQueue * globalLuminosityBlocksQueue() final
Definition: WorkerT.cc:163
void operator()(WorkerT< T > *iWorker, StreamID id, INFOTYPE const &info, ModuleCallingContext const *mcc)
Definition: WorkerT.cc:106
void implEndJob() override
Definition: WorkerT.cc:611
std::string workerType() const override
Definition: WorkerT.cc:601
void callWorkerStreamEnd(D, StreamID, RunTransitionInfo const &, ModuleCallingContext const *)
Definition: WorkerT.cc:516
bool wantsStreamLuminosityBlocks() const final
Definition: WorkerT.cc:154
bool implNeedToRunSelection() const final
Definition: WorkerT.cc:419
bool implDoStreamEnd(StreamID, RunTransitionInfo const &, ModuleCallingContext const *) override
Definition: WorkerT.cc:533
bool implDoPrePrefetchSelection(StreamID, EventPrincipal const &, ModuleCallingContext const *) override
Definition: WorkerT.cc:424
assert(be >=bs)
bool implDoAccessInputProcessBlock(ProcessBlockPrincipal const &, ModuleCallingContext const *) override
Definition: WorkerT.cc:488
BranchType
Definition: BranchType.h:11
void callWorkerStreamBegin(D, StreamID, RunTransitionInfo const &, ModuleCallingContext const *)
Definition: WorkerT.cc:507
edm::propagate_const< std::shared_ptr< T > > module_
Definition: WorkerT.h:170
void itemsToGetForSelection(std::vector< ProductResolverIndexAndSkipBit > &) const final
Definition: WorkerT.cc:430
size_t transformIndex(edm::BranchDescription const &) const final
Definition: WorkerT.cc:352
void implRespondToOpenInputFile(FileBlock const &fb) override
Definition: WorkerT.cc:648
void implRespondToCloseOutputFile() override
Definition: WorkerT.cc:658
Types moduleType() const override
int iEvent
Definition: GenABIO.cc:224
void doneWaiting(std::exception_ptr iExcept)
void callWorkerEndStream(D, StreamID)
Definition: WorkerT.cc:633
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
void operator()(WorkerT< T > *iWorker, StreamID id)
Definition: WorkerT.cc:96
void operator()(const T &...)
Definition: WorkerT.cc:91
void implBeginStream(StreamID) override
Definition: WorkerT.cc:622
void resolvePutIndicies(BranchType iBranchType, std::unordered_multimap< std::string, std::tuple< TypeID const *, const char *, edm::ProductResolverIndex >> const &iIndicies) final
Definition: WorkerT.cc:849
bool implDoStreamBegin(StreamID, RunTransitionInfo const &, ModuleCallingContext const *) override
Definition: WorkerT.cc:521
bool wantsInputProcessBlocks() const final
Definition: WorkerT.cc:134
Definition: value.py:1
TaskQueueAdaptor serializeRunModule() override
Definition: WorkerT.cc:669
ServiceToken lock() const
Definition: ServiceToken.h:101
void operator()(WorkerT< T > *iWorker, StreamID id)
Definition: WorkerT.cc:101
bool wantsGlobalLuminosityBlocks() const final
Definition: WorkerT.cc:144
ConcurrencyTypes
Definition: Worker.h:96
~WorkerT() override
Definition: WorkerT.cc:126
bool implDoBeginProcessBlock(ProcessBlockPrincipal const &, ModuleCallingContext const *) override
Definition: WorkerT.cc:482
DecomposeProduct< arg, typename Div::arg > D
Definition: Factorize.h:141
void implEndStream(StreamID) override
Definition: WorkerT.cc:638
void implDoTransformAsync(WaitingTaskHolder, size_t iTransformIndex, EventPrincipal const &, ParentContext const &, ServiceWeakToken const &) final
Definition: WorkerT.cc:272
void implBeginJob() override
Definition: WorkerT.cc:606
bool wantsProcessBlocks() const final
Definition: WorkerT.cc:129
void implRespondToCloseInputFile(FileBlock const &fb) override
Definition: WorkerT.cc:653
bool implDoEnd(RunTransitionInfo const &, ModuleCallingContext const *) override
Definition: WorkerT.cc:543
void resolvePutIndicies(BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)
void callWorkerBeginStream(D, StreamID)
Definition: WorkerT.cc:617
void implDoAcquire(EventTransitionInfo const &, ModuleCallingContext const *, WaitingTaskWithArenaHolder &) final
Definition: WorkerT.cc:232
HLT enums.
ProductResolverIndex itemToGetForTransform(size_t iTransformIndex) const final
Definition: WorkerT.cc:385
bool wantsGlobalRuns() const final
Definition: WorkerT.cc:139
bool wantsStreamRuns() const final
Definition: WorkerT.cc:149
void implRegisterThinnedAssociations(ProductRegistry const &, ThinnedAssociationsHelper &) override
Definition: WorkerT.cc:663
bool implDoBegin(RunTransitionInfo const &, ModuleCallingContext const *) override
Definition: WorkerT.cc:500
long double T
WorkerT(std::shared_ptr< T >, ModuleDescription const &, ExceptionToActionTable const *actions)
Definition: WorkerT.cc:120
void selectInputProcessBlocks(ProductRegistry const &, ProcessBlockHelperBase const &) final
Definition: WorkerT.cc:811
ConcurrencyTypes moduleConcurrencyType() const override
bool implDo(EventTransitionInfo const &, ModuleCallingContext const *) override
Definition: WorkerT.cc:225