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 }
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
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 }
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
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 }
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
0916
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 }