File indexing completed on 2025-01-31 02:19:30
0001
0002
0003
0004
0005
0006
0007
0008 #ifdef __clang__
0009 #pragma GCC diagnostic ignored "-Wc++20-extensions"
0010 #endif
0011
0012 #include "DataFormats/Common/interface/Handle.h"
0013 #include "DataFormats/Common/interface/TriggerResults.h"
0014 #include "DataFormats/TestObjects/interface/ToyProducts.h"
0015
0016 #include "FWCore/Framework/interface/stream/EDProducer.h"
0017 #include "FWCore/Framework/interface/global/EDProducer.h"
0018 #include "FWCore/Framework/interface/limited/EDProducer.h"
0019 #include "FWCore/Framework/interface/one/EDProducer.h"
0020 #include "FWCore/Framework/interface/Event.h"
0021 #include "FWCore/Framework/interface/MakerMacros.h"
0022 #include "FWCore/Framework/interface/ProcessBlock.h"
0023 #include "FWCore/Framework/interface/GetterOfProducts.h"
0024 #include "FWCore/Framework/interface/TypeMatch.h"
0025 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0026 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0027 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0028 #include "FWCore/Utilities/interface/EDMException.h"
0029 #include "FWCore/Utilities/interface/InputTag.h"
0030 #include "FWCore/Utilities/interface/transform.h"
0031
0032 #include <cassert>
0033 #include <string>
0034 #include <vector>
0035 #include <chrono>
0036
0037 namespace edmtest {
0038
0039
0040
0041
0042
0043
0044
0045
0046
0047
0048
0049
0050
0051 class FailingProducer : public edm::global::EDProducer<> {
0052 public:
0053 explicit FailingProducer(edm::ParameterSet const& ) { produces<IntProduct>(); }
0054 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0055 };
0056
0057 void FailingProducer::produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const {
0058
0059 throw edm::Exception(edm::errors::NotFound) << "Intentional 'NotFound' exception for testing purposes\n";
0060 }
0061
0062
0063
0064
0065
0066
0067 class FailingInLumiProducer : public edm::global::EDProducer<edm::BeginLuminosityBlockProducer> {
0068 public:
0069 explicit FailingInLumiProducer(edm::ParameterSet const& ) {
0070 produces<IntProduct, edm::Transition::BeginLuminosityBlock>();
0071 }
0072 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0073
0074 void globalBeginLuminosityBlockProduce(edm::LuminosityBlock&, edm::EventSetup const&) const override;
0075 };
0076
0077 void FailingInLumiProducer::produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const {}
0078 void FailingInLumiProducer::globalBeginLuminosityBlockProduce(edm::LuminosityBlock&, edm::EventSetup const&) const {
0079
0080 throw edm::Exception(edm::errors::NotFound) << "Intentional 'NotFound' exception for testing purposes\n";
0081 }
0082
0083
0084
0085
0086
0087
0088
0089 class FailingInRunProducer : public edm::global::EDProducer<edm::BeginRunProducer> {
0090 public:
0091 explicit FailingInRunProducer(edm::ParameterSet const& ) { produces<IntProduct, edm::Transition::BeginRun>(); }
0092 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0093
0094 void globalBeginRunProduce(edm::Run&, edm::EventSetup const&) const override;
0095 };
0096
0097 void FailingInRunProducer::produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const {}
0098 void FailingInRunProducer::globalBeginRunProduce(edm::Run&, edm::EventSetup const&) const {
0099
0100 throw edm::Exception(edm::errors::NotFound) << "Intentional 'NotFound' exception for testing purposes\n";
0101 }
0102
0103
0104
0105
0106
0107
0108 class NonProducer : public edm::global::EDProducer<> {
0109 public:
0110 explicit NonProducer(edm::ParameterSet const& ) { produces<IntProduct>(); }
0111 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0112 };
0113
0114 void NonProducer::produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const {}
0115
0116
0117
0118
0119
0120
0121 class IntProducer : public edm::stream::EDProducer<> {
0122 public:
0123 explicit IntProducer(edm::ParameterSet const& p)
0124 : token_{produces<IntProduct>()}, value_(p.getParameter<int>("ivalue")) {}
0125 void produce(edm::Event& e, edm::EventSetup const& c) override;
0126
0127 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0128 edm::ParameterSetDescription desc;
0129 desc.add<int>("ivalue");
0130 descriptions.addDefault(desc);
0131 }
0132
0133 private:
0134 edm::EDPutTokenT<IntProduct> token_;
0135 int value_;
0136 };
0137
0138 void IntProducer::produce(edm::Event& e, edm::EventSetup const&) {
0139
0140 e.emplace(token_, value_);
0141 }
0142
0143
0144
0145
0146
0147 class IntOneSharedProducer : public edm::one::EDProducer<edm::one::SharedResources> {
0148 public:
0149 explicit IntOneSharedProducer(edm::ParameterSet const& p) : value_(p.getParameter<int>("ivalue")) {
0150 produces<IntProduct>();
0151 for (auto const& r : p.getUntrackedParameter<std::vector<std::string>>("resourceNames")) {
0152 usesResource(r);
0153 }
0154 }
0155 explicit IntOneSharedProducer(int i) : value_(i) {
0156 produces<IntProduct>();
0157 usesResource("IntOneShared");
0158 }
0159 void produce(edm::Event& e, edm::EventSetup const& c) override;
0160
0161 static void fillDescriptions(edm::ConfigurationDescriptions& iConfig) {
0162 edm::ParameterSetDescription desc;
0163 desc.add<int>("ivalue");
0164 desc.addUntracked<std::vector<std::string>>("resourceNames", std::vector<std::string>{});
0165
0166 iConfig.addDefault(desc);
0167 }
0168
0169 private:
0170 int value_;
0171 };
0172
0173 void IntOneSharedProducer::produce(edm::Event& e, edm::EventSetup const&) {
0174
0175 e.put(std::make_unique<IntProduct>(value_));
0176 }
0177
0178
0179
0180
0181
0182
0183 class BusyWaitIntProducer : public edm::global::EDProducer<> {
0184 public:
0185 explicit BusyWaitIntProducer(edm::ParameterSet const& p)
0186 : token_{produces<IntProduct>()},
0187 value_(p.getParameter<int>("ivalue")),
0188 iterations_(p.getParameter<unsigned int>("iterations")),
0189 pi_(std::acos(-1)),
0190 lumiNumberToThrow_(p.getParameter<unsigned int>("lumiNumberToThrow")) {}
0191
0192 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0193
0194 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0195
0196 private:
0197 const edm::EDPutTokenT<IntProduct> token_;
0198 const int value_;
0199 const unsigned int iterations_;
0200 const double pi_;
0201 const unsigned int lumiNumberToThrow_;
0202 };
0203
0204 void BusyWaitIntProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0205 double sum = 0.;
0206 const double stepSize = pi_ / iterations_;
0207 for (unsigned int i = 0; i < iterations_; ++i) {
0208 sum += stepSize * cos(i * stepSize);
0209 }
0210
0211 e.emplace(token_, value_ + sum);
0212
0213 if (e.luminosityBlock() == lumiNumberToThrow_) {
0214 throw cms::Exception("Test");
0215 }
0216 }
0217
0218 void BusyWaitIntProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0219 edm::ParameterSetDescription desc;
0220 desc.add<int>("ivalue");
0221 desc.add<unsigned int>("iterations");
0222 desc.add<unsigned int>("lumiNumberToThrow", 0);
0223 descriptions.addDefault(desc);
0224 }
0225
0226
0227 class BusyWaitIntLimitedProducer : public edm::limited::EDProducer<> {
0228 public:
0229 explicit BusyWaitIntLimitedProducer(edm::ParameterSet const& p)
0230 : edm::limited::EDProducerBase(p),
0231 edm::limited::EDProducer<>(p),
0232 token_{produces<IntProduct>()},
0233 value_(p.getParameter<int>("ivalue")),
0234 iterations_(p.getParameter<unsigned int>("iterations")),
0235 pi_(std::acos(-1)) {}
0236
0237 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0238
0239 private:
0240 const edm::EDPutTokenT<IntProduct> token_;
0241 const int value_;
0242 const unsigned int iterations_;
0243 const double pi_;
0244 mutable std::atomic<unsigned int> reentrancy_{0};
0245 };
0246
0247 void BusyWaitIntLimitedProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0248 auto v = ++reentrancy_;
0249 if (v > concurrencyLimit()) {
0250 --reentrancy_;
0251 throw cms::Exception("NotLimited", "produce called to many times concurrently.");
0252 }
0253
0254 double sum = 0.;
0255 const double stepSize = pi_ / iterations_;
0256 for (unsigned int i = 0; i < iterations_; ++i) {
0257 sum += stepSize * cos(i * stepSize);
0258 }
0259
0260 e.emplace(token_, value_ + sum);
0261 --reentrancy_;
0262 }
0263
0264
0265 class BusyWaitIntOneSharedProducer : public edm::one::EDProducer<edm::one::SharedResources> {
0266 public:
0267 explicit BusyWaitIntOneSharedProducer(edm::ParameterSet const& p)
0268 : value_(p.getParameter<int>("ivalue")),
0269 iterations_(p.getParameter<unsigned int>("iterations")),
0270 pi_(std::acos(-1)) {
0271 for (auto const& r : p.getUntrackedParameter<std::vector<std::string>>("resourceNames")) {
0272 usesResource(r);
0273 }
0274 produces<IntProduct>();
0275 }
0276
0277 static void fillDescriptions(edm::ConfigurationDescriptions& iConfig) {
0278 edm::ParameterSetDescription desc;
0279 desc.add<int>("ivalue");
0280 desc.add<unsigned int>("iterations");
0281 desc.addUntracked<std::vector<std::string>>("resourceNames", std::vector<std::string>{});
0282
0283 iConfig.addDefault(desc);
0284 }
0285
0286 void produce(edm::Event& e, edm::EventSetup const& c) override;
0287
0288 private:
0289 const int value_;
0290 const unsigned int iterations_;
0291 const double pi_;
0292 };
0293
0294 void BusyWaitIntOneSharedProducer::produce(edm::Event& e, edm::EventSetup const&) {
0295 double sum = 0.;
0296 const double stepSize = pi_ / iterations_;
0297 for (unsigned int i = 0; i < iterations_; ++i) {
0298 sum += stepSize * cos(i * stepSize);
0299 }
0300
0301 e.put(std::make_unique<IntProduct>(value_ + sum));
0302 }
0303
0304
0305
0306 class ConsumingIntProducer : public edm::stream::EDProducer<> {
0307 public:
0308 explicit ConsumingIntProducer(edm::ParameterSet const& p)
0309 : getterOfTriggerResults_(edm::TypeMatch(), this),
0310 token_{produces<IntProduct>()},
0311 value_(p.getParameter<int>("ivalue")) {
0312
0313 consumes<edm::TriggerResults>(edm::InputTag("TriggerResults"));
0314 callWhenNewProductsRegistered(getterOfTriggerResults_);
0315 }
0316 void produce(edm::Event& e, edm::EventSetup const& c) override;
0317
0318 private:
0319 edm::GetterOfProducts<edm::TriggerResults> getterOfTriggerResults_;
0320 const edm::EDPutTokenT<IntProduct> token_;
0321 const int value_;
0322 };
0323
0324 void ConsumingIntProducer::produce(edm::Event& e, edm::EventSetup const&) { e.emplace(token_, value_); }
0325
0326
0327
0328
0329
0330
0331 class EventNumberIntProducer : public edm::global::EDProducer<> {
0332 public:
0333 explicit EventNumberIntProducer(edm::ParameterSet const&) : token_{produces<UInt64Product>()} {}
0334 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0335
0336 private:
0337 const edm::EDPutTokenT<UInt64Product> token_;
0338 };
0339
0340 void EventNumberIntProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0341
0342 e.emplace(token_, e.id().event());
0343 }
0344
0345
0346
0347
0348
0349 class TransientIntProducer : public edm::global::EDProducer<> {
0350 public:
0351 explicit TransientIntProducer(edm::ParameterSet const& p)
0352 : token_{produces<TransientIntProduct>()}, value_(p.getParameter<int>("ivalue")) {}
0353 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0354
0355 private:
0356 const edm::EDPutTokenT<TransientIntProduct> token_;
0357 const int value_;
0358 };
0359
0360 void TransientIntProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0361
0362 e.emplace(token_, value_);
0363 }
0364
0365
0366
0367
0368
0369 class IntProducerFromTransient : public edm::global::EDProducer<> {
0370 public:
0371 explicit IntProducerFromTransient(edm::ParameterSet const&)
0372 : putToken_{produces<IntProduct>()}, getToken_{consumes(edm::InputTag{"TransientThing"})} {}
0373 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0374
0375 private:
0376 const edm::EDPutTokenT<IntProduct> putToken_;
0377 const edm::EDGetTokenT<TransientIntProduct> getToken_;
0378 };
0379
0380 void IntProducerFromTransient::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0381
0382 auto result = e.getHandle(getToken_);
0383 assert(result);
0384 e.emplace(putToken_, result.product()->value);
0385 }
0386
0387
0388
0389
0390
0391 class TransientIntParentProducer : public edm::global::EDProducer<> {
0392 public:
0393 explicit TransientIntParentProducer(edm::ParameterSet const& p)
0394 : token_{produces<TransientIntParent>()}, value_(p.getParameter<int>("ivalue")) {}
0395 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0396
0397 private:
0398 const edm::EDPutTokenT<TransientIntParent> token_;
0399 const int value_;
0400 };
0401
0402 void TransientIntParentProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0403
0404 e.emplace(token_, value_);
0405 }
0406
0407
0408
0409
0410
0411 class IntProducerFromTransientParent : public edm::global::EDProducer<> {
0412 public:
0413 explicit IntProducerFromTransientParent(edm::ParameterSet const& p)
0414 : putToken_{produces<IntProduct>()}, getToken_{consumes(p.getParameter<edm::InputTag>("src"))} {}
0415 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0416
0417 private:
0418 const edm::EDPutTokenT<IntProduct> putToken_;
0419 const edm::EDGetTokenT<TransientIntParent> getToken_;
0420 };
0421
0422 void IntProducerFromTransientParent::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0423
0424 e.emplace(putToken_, e.get(getToken_).value);
0425 }
0426
0427
0428
0429
0430
0431 class Int16_tProducer : public edm::global::EDProducer<> {
0432 public:
0433 explicit Int16_tProducer(edm::ParameterSet const& p)
0434 : token_{produces<Int16_tProduct>()}, value_(p.getParameter<int>("ivalue")) {}
0435 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0436
0437 private:
0438 const edm::EDPutTokenT<Int16_tProduct> token_;
0439 const int16_t value_;
0440 };
0441
0442 void Int16_tProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0443
0444 e.emplace(token_, value_);
0445 }
0446
0447
0448
0449
0450
0451 class AddIntsProducer : public edm::global::EDProducer<> {
0452 public:
0453 explicit AddIntsProducer(edm::ParameterSet const& p)
0454 : putToken_{produces<IntProduct>()},
0455 otherPutToken_{produces<IntProduct>("other")},
0456 onlyGetOnEvent_(p.getUntrackedParameter<unsigned int>("onlyGetOnEvent")) {
0457 auto const& labels = p.getParameter<std::vector<edm::InputTag>>("labels");
0458 for (auto const& label : labels) {
0459 tokens_.emplace_back(consumes(label));
0460 }
0461 }
0462 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0463
0464 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0465 edm::ParameterSetDescription desc;
0466 desc.addUntracked<unsigned int>("onlyGetOnEvent", 0u);
0467 desc.add<std::vector<edm::InputTag>>("labels");
0468 descriptions.addDefault(desc);
0469 }
0470
0471 private:
0472 std::vector<edm::EDGetTokenT<IntProduct>> tokens_;
0473 const edm::EDPutTokenT<IntProduct> putToken_;
0474 const edm::EDPutTokenT<IntProduct> otherPutToken_;
0475 unsigned int onlyGetOnEvent_;
0476 };
0477
0478 void AddIntsProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0479
0480 int value = 0;
0481
0482 if (onlyGetOnEvent_ == 0u || e.eventAuxiliary().event() == onlyGetOnEvent_) {
0483 for (auto const& token : tokens_) {
0484 value += e.get(token).value;
0485 }
0486 }
0487 e.emplace(putToken_, value);
0488 e.emplace(otherPutToken_, value);
0489 }
0490
0491
0492
0493
0494
0495 class AddAllIntsProducer : public edm::global::EDProducer<> {
0496 public:
0497 explicit AddAllIntsProducer(edm::ParameterSet const& p) : putToken_{produces()} {
0498 getter_ = edm::GetterOfProducts<IntProduct>(edm::TypeMatch(), this);
0499 callWhenNewProductsRegistered(*getter_);
0500 }
0501 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0502
0503 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0504 edm::ParameterSetDescription desc;
0505 descriptions.addDefault(desc);
0506 }
0507
0508 private:
0509 const edm::EDPutTokenT<int> putToken_;
0510 std::optional<edm::GetterOfProducts<IntProduct>> getter_;
0511 };
0512
0513 void AddAllIntsProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0514 std::vector<edm::Handle<IntProduct>> ints;
0515 getter_->fillHandles(e, ints);
0516
0517 int value = 0;
0518 for (auto const& i : ints) {
0519 value += i->value;
0520 }
0521
0522 e.emplace(putToken_, value);
0523 }
0524
0525
0526
0527
0528
0529 class ManyIntProducer : public edm::global::EDProducer<> {
0530 public:
0531 explicit ManyIntProducer(edm::ParameterSet const& p)
0532 : tokenValues_{vector_transform(
0533 p.getParameter<std::vector<edm::ParameterSet>>("values"),
0534 [this](edm::ParameterSet const& pset) {
0535 auto const& branchAlias = pset.getParameter<std::string>("branchAlias");
0536 if (not branchAlias.empty()) {
0537 return TokenValue{
0538 produces<IntProduct>(pset.getParameter<std::string>("instance")).setBranchAlias(branchAlias),
0539 pset.getParameter<int>("value")};
0540 }
0541 return TokenValue{produces<IntProduct>(pset.getParameter<std::string>("instance")),
0542 pset.getParameter<int>("value")};
0543 })},
0544 transientTokenValues_{vector_transform(
0545 p.getParameter<std::vector<edm::ParameterSet>>("transientValues"),
0546 [this](edm::ParameterSet const& pset) {
0547 auto const& branchAlias = pset.getParameter<std::string>("branchAlias");
0548 if (not branchAlias.empty()) {
0549 return TransientTokenValue{produces<TransientIntProduct>(pset.getParameter<std::string>("instance"))
0550 .setBranchAlias(branchAlias),
0551 pset.getParameter<int>("value")};
0552 }
0553 return TransientTokenValue{produces<TransientIntProduct>(pset.getParameter<std::string>("instance")),
0554 pset.getParameter<int>("value")};
0555 })},
0556 throw_{p.getUntrackedParameter<bool>("throw")} {
0557 tokenValues_.push_back(TokenValue{produces<IntProduct>(), p.getParameter<int>("ivalue")});
0558 }
0559
0560 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0561 edm::ParameterSetDescription desc;
0562 desc.add<int>("ivalue");
0563 desc.addUntracked<bool>("throw", false);
0564
0565 {
0566 edm::ParameterSetDescription pset;
0567 pset.add<std::string>("instance");
0568 pset.add<int>("value");
0569 pset.add<std::string>("branchAlias", "");
0570 desc.addVPSet("values", pset, std::vector<edm::ParameterSet>{});
0571 desc.addVPSet("transientValues", pset, std::vector<edm::ParameterSet>{});
0572 }
0573
0574 descriptions.addDefault(desc);
0575 }
0576
0577 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0578
0579 private:
0580 struct TokenValue {
0581 edm::EDPutTokenT<IntProduct> token;
0582 int value;
0583 };
0584 std::vector<TokenValue> tokenValues_;
0585
0586 struct TransientTokenValue {
0587 edm::EDPutTokenT<TransientIntProduct> token;
0588 int value;
0589 };
0590 std::vector<TransientTokenValue> transientTokenValues_;
0591
0592 bool throw_;
0593 };
0594
0595 void ManyIntProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0596 if (throw_) {
0597 throw edm::Exception(edm::errors::NotFound) << "Intentional 'NotFound' exception for testing purposes\n";
0598 }
0599
0600
0601 for (auto const& tv : tokenValues_) {
0602 e.emplace(tv.token, tv.value);
0603 }
0604 for (auto const& tv : transientTokenValues_) {
0605 e.emplace(tv.token, tv.value);
0606 }
0607 }
0608
0609
0610
0611
0612
0613 class ManyIntWhenRegisteredProducer : public edm::global::EDProducer<> {
0614 public:
0615 explicit ManyIntWhenRegisteredProducer(edm::ParameterSet const& p)
0616 : sourceLabel_(p.getParameter<std::string>("src")) {
0617 callWhenNewProductsRegistered([=, this](edm::ProductDescription const& iBranch) {
0618 if (iBranch.moduleLabel() == sourceLabel_) {
0619 if (iBranch.branchType() != edm::InEvent) {
0620 throw edm::Exception(edm::errors::UnimplementedFeature)
0621 << "ManyIntWhenRegisteredProducer supports only event branches";
0622 }
0623
0624 this->tokens_.push_back(
0625 Tokens{this->consumes<IntProduct>(
0626 edm::InputTag{iBranch.moduleLabel(), iBranch.productInstanceName(), iBranch.processName()}),
0627 this->produces<IntProduct>(iBranch.productInstanceName())});
0628 }
0629 });
0630 }
0631
0632 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0633 edm::ParameterSetDescription desc;
0634 desc.add<std::string>("src");
0635 descriptions.addDefault(desc);
0636 }
0637
0638 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0639
0640 private:
0641 struct Tokens {
0642 edm::EDGetTokenT<IntProduct> get;
0643 edm::EDPutTokenT<IntProduct> put;
0644 };
0645
0646 std::string sourceLabel_;
0647 std::vector<Tokens> tokens_;
0648 };
0649
0650 void ManyIntWhenRegisteredProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0651 for (auto const& toks : tokens_) {
0652 e.emplace(toks.put, e.get(toks.get));
0653 }
0654 };
0655
0656
0657
0658 class NonEventIntProducer : public edm::global::EDProducer<edm::Accumulator,
0659 edm::BeginRunProducer,
0660 edm::BeginLuminosityBlockProducer,
0661 edm::EndLuminosityBlockProducer,
0662 edm::EndRunProducer,
0663 edm::BeginProcessBlockProducer,
0664 edm::EndProcessBlockProducer,
0665 edm::InputProcessBlockCache<>> {
0666 public:
0667 explicit NonEventIntProducer(edm::ParameterSet const& p)
0668 : bpbToken_{produces<IntProduct, edm::Transition::BeginProcessBlock>("beginProcessBlock")},
0669 brToken_{produces<IntProduct, edm::Transition::BeginRun>("beginRun")},
0670 blToken_{produces<IntProduct, edm::Transition::BeginLuminosityBlock>("beginLumi")},
0671 elToken_{produces<IntProduct, edm::Transition::EndLuminosityBlock>("endLumi")},
0672 erToken_{produces<IntProduct, edm::Transition::EndRun>("endRun")},
0673 epbToken_{produces<IntProduct, edm::Transition::EndProcessBlock>("endProcessBlock")},
0674 value_(p.getParameter<int>("ivalue")),
0675 sleepTime_(p.getParameter<unsigned int>("sleepTime")),
0676 bpbExpect_{p.getUntrackedParameter<int>("expectBeginProcessBlock")},
0677 brExpect_{p.getUntrackedParameter<int>("expectBeginRun")},
0678 blExpect_{p.getUntrackedParameter<int>("expectBeginLuminosityBlock")},
0679 elExpect_{p.getUntrackedParameter<int>("expectEndLuminosityBlock")},
0680 erExpect_{p.getUntrackedParameter<int>("expectEndRun")},
0681 epbExpect_{p.getUntrackedParameter<int>("expectEndProcessBlock")},
0682 aipbExpect_{p.getUntrackedParameter<int>("expectAccessInputProcessBlock")} {
0683 {
0684 auto tag = p.getParameter<edm::InputTag>("consumesBeginProcessBlock");
0685 if (not tag.label().empty()) {
0686 bpbGet_ = consumes<edm::InProcess>(tag);
0687 }
0688 }
0689 {
0690 auto tag = p.getParameter<edm::InputTag>("consumesBeginRun");
0691 if (not tag.label().empty()) {
0692 brGet_ = consumes<edm::InRun>(tag);
0693 }
0694 }
0695 {
0696 auto tag = p.getParameter<edm::InputTag>("consumesBeginLuminosityBlock");
0697 if (not tag.label().empty()) {
0698 blGet_ = consumes<edm::InLumi>(tag);
0699 }
0700 }
0701 {
0702 auto tag = p.getParameter<edm::InputTag>("consumesEndLuminosityBlock");
0703 if (not tag.label().empty()) {
0704 elGet_ = consumes<edm::InLumi>(tag);
0705 }
0706 }
0707 {
0708 auto tag = p.getParameter<edm::InputTag>("consumesEndRun");
0709 if (not tag.label().empty()) {
0710 erGet_ = consumes<edm::InRun>(tag);
0711 }
0712 }
0713 {
0714 auto tag = p.getParameter<edm::InputTag>("consumesEndProcessBlock");
0715 if (not tag.label().empty()) {
0716 epbGet_ = consumes<edm::InProcess>(tag);
0717 }
0718 }
0719 {
0720 auto tag = p.getParameter<edm::InputTag>("consumesAccessInputProcessBlock");
0721 if (not tag.label().empty()) {
0722 aipbGet_ = consumes<edm::InProcess>(tag);
0723 }
0724 }
0725 }
0726 void accumulate(edm::StreamID iID, edm::Event const& e, edm::EventSetup const& c) const override;
0727 void beginProcessBlockProduce(edm::ProcessBlock&) override;
0728 void endProcessBlockProduce(edm::ProcessBlock&) override;
0729 void globalBeginRunProduce(edm::Run& e, edm::EventSetup const&) const override;
0730 void globalEndRunProduce(edm::Run& e, edm::EventSetup const&) const override;
0731 void globalBeginLuminosityBlockProduce(edm::LuminosityBlock& e, edm::EventSetup const&) const override;
0732 void globalEndLuminosityBlockProduce(edm::LuminosityBlock& e, edm::EventSetup const&) const override;
0733 void accessInputProcessBlock(edm::ProcessBlock const&) override;
0734
0735 static void fillDescriptions(edm::ConfigurationDescriptions& conf) {
0736 edm::ParameterSetDescription desc;
0737 desc.add<int>("ivalue", 0);
0738 desc.add<unsigned int>("sleepTime", 0);
0739 desc.add<edm::InputTag>("consumesBeginProcessBlock", {});
0740 desc.addUntracked<int>("expectBeginProcessBlock", 0);
0741 desc.add<edm::InputTag>("consumesEndProcessBlock", {});
0742 desc.addUntracked<int>("expectEndProcessBlock", 0);
0743 desc.add<edm::InputTag>("consumesAccessInputProcessBlock", {});
0744 desc.addUntracked<int>("expectAccessInputProcessBlock", 0);
0745 desc.add<edm::InputTag>("consumesBeginRun", {});
0746 desc.addUntracked<int>("expectBeginRun", 0);
0747 desc.add<edm::InputTag>("consumesEndRun", {});
0748 desc.addUntracked<int>("expectEndRun", 0);
0749 desc.add<edm::InputTag>("consumesBeginLuminosityBlock", {});
0750 desc.addUntracked<int>("expectBeginLuminosityBlock", 0);
0751 desc.add<edm::InputTag>("consumesEndLuminosityBlock", {});
0752 desc.addUntracked<int>("expectEndLuminosityBlock", 0);
0753
0754 conf.addDefault(desc);
0755 }
0756
0757 private:
0758 void check(IntProduct, int) const;
0759 const edm::EDPutTokenT<IntProduct> bpbToken_;
0760 const edm::EDPutTokenT<IntProduct> brToken_;
0761 const edm::EDPutTokenT<IntProduct> blToken_;
0762 const edm::EDPutTokenT<IntProduct> elToken_;
0763 const edm::EDPutTokenT<IntProduct> erToken_;
0764 const edm::EDPutTokenT<IntProduct> epbToken_;
0765 const int value_;
0766 const unsigned int sleepTime_;
0767 edm::EDGetTokenT<IntProduct> bpbGet_;
0768 edm::EDGetTokenT<IntProduct> brGet_;
0769 edm::EDGetTokenT<IntProduct> blGet_;
0770 edm::EDGetTokenT<IntProduct> elGet_;
0771 edm::EDGetTokenT<IntProduct> erGet_;
0772 edm::EDGetTokenT<IntProduct> epbGet_;
0773 edm::EDGetTokenT<IntProduct> aipbGet_;
0774 const int bpbExpect_;
0775 const int brExpect_;
0776 const int blExpect_;
0777 const int elExpect_;
0778 const int erExpect_;
0779 const int epbExpect_;
0780 const int aipbExpect_;
0781 };
0782
0783 void NonEventIntProducer::accumulate(edm::StreamID iID, edm::Event const& e, edm::EventSetup const&) const {}
0784 void NonEventIntProducer::beginProcessBlockProduce(edm::ProcessBlock& processBlock) {
0785 if (not bpbGet_.isUninitialized()) {
0786 check(processBlock.get(bpbGet_), bpbExpect_);
0787 }
0788 if (sleepTime_ > 0) {
0789
0790
0791
0792
0793 std::this_thread::sleep_for(std::chrono::microseconds(sleepTime_));
0794 }
0795 processBlock.emplace(bpbToken_, value_);
0796 }
0797 void NonEventIntProducer::endProcessBlockProduce(edm::ProcessBlock& processBlock) {
0798 if (not epbGet_.isUninitialized()) {
0799 check(processBlock.get(epbGet_), epbExpect_);
0800 }
0801 if (sleepTime_ > 0) {
0802 std::this_thread::sleep_for(std::chrono::microseconds(sleepTime_));
0803 }
0804 processBlock.emplace(epbToken_, value_);
0805 }
0806 void NonEventIntProducer::accessInputProcessBlock(edm::ProcessBlock const& processBlock) {
0807 if (not aipbGet_.isUninitialized()) {
0808 check(processBlock.get(aipbGet_), aipbExpect_);
0809 }
0810 if (sleepTime_ > 0) {
0811 std::this_thread::sleep_for(std::chrono::microseconds(sleepTime_));
0812 }
0813 }
0814 void NonEventIntProducer::globalBeginRunProduce(edm::Run& r, edm::EventSetup const&) const {
0815 if (not brGet_.isUninitialized()) {
0816 check(r.get(brGet_), brExpect_);
0817 }
0818 if (sleepTime_ > 0) {
0819 std::this_thread::sleep_for(std::chrono::microseconds(sleepTime_));
0820 }
0821 r.emplace(brToken_, value_);
0822 }
0823 void NonEventIntProducer::globalEndRunProduce(edm::Run& r, edm::EventSetup const&) const {
0824 if (not erGet_.isUninitialized()) {
0825 check(r.get(erGet_), erExpect_);
0826 }
0827 if (sleepTime_ > 0) {
0828 std::this_thread::sleep_for(std::chrono::microseconds(sleepTime_));
0829 }
0830 r.emplace(erToken_, value_);
0831 }
0832 void NonEventIntProducer::globalBeginLuminosityBlockProduce(edm::LuminosityBlock& l, edm::EventSetup const&) const {
0833 if (not blGet_.isUninitialized()) {
0834 check(l.get(blGet_), blExpect_);
0835 }
0836 if (sleepTime_ > 0) {
0837 std::this_thread::sleep_for(std::chrono::microseconds(sleepTime_));
0838 }
0839 l.emplace(blToken_, value_);
0840 }
0841 void NonEventIntProducer::globalEndLuminosityBlockProduce(edm::LuminosityBlock& l, edm::EventSetup const&) const {
0842 if (not elGet_.isUninitialized()) {
0843 check(l.get(elGet_), elExpect_);
0844 }
0845 if (sleepTime_ > 0) {
0846 std::this_thread::sleep_for(std::chrono::microseconds(sleepTime_));
0847 }
0848 l.emplace(elToken_, value_);
0849 }
0850 void NonEventIntProducer::check(IntProduct iProd, int iExpect) const {
0851 if (iExpect != iProd.value) {
0852 throw cms::Exception("BadValue") << "expected " << iExpect << " but got " << iProd.value;
0853 }
0854 }
0855
0856
0857
0858
0859
0860 class IntProducerBeginProcessBlock : public edm::global::EDProducer<edm::BeginProcessBlockProducer> {
0861 public:
0862 explicit IntProducerBeginProcessBlock(edm::ParameterSet const& p)
0863 : token_{produces<IntProduct, edm::Transition::BeginProcessBlock>()}, value_(p.getParameter<int>("ivalue")) {}
0864 void produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {}
0865 void beginProcessBlockProduce(edm::ProcessBlock&) override;
0866
0867 private:
0868 edm::EDPutTokenT<IntProduct> token_;
0869 int value_;
0870 };
0871
0872 void IntProducerBeginProcessBlock::beginProcessBlockProduce(edm::ProcessBlock& processBlock) {
0873 processBlock.emplace(token_, value_);
0874 }
0875
0876
0877
0878
0879
0880 class IntProducerEndProcessBlock : public edm::global::EDProducer<edm::EndProcessBlockProducer> {
0881 public:
0882 explicit IntProducerEndProcessBlock(edm::ParameterSet const& p)
0883 : token_{produces<IntProduct, edm::Transition::EndProcessBlock>()},
0884 token2_{produces<IntProduct, edm::Transition::EndProcessBlock>("two")},
0885 token3_{produces<IntProduct, edm::Transition::EndProcessBlock>("three")},
0886 token4_{produces<IntProduct, edm::Transition::EndProcessBlock>("four")},
0887 value_(p.getParameter<int>("ivalue")) {}
0888 void produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {}
0889 void endProcessBlockProduce(edm::ProcessBlock&) override;
0890
0891 private:
0892 edm::EDPutTokenT<IntProduct> token_;
0893 edm::EDPutToken token2_;
0894 edm::EDPutTokenT<IntProduct> token3_;
0895 edm::EDPutToken token4_;
0896 int value_;
0897 };
0898
0899 void IntProducerEndProcessBlock::endProcessBlockProduce(edm::ProcessBlock& processBlock) {
0900 processBlock.emplace(token_, value_);
0901 processBlock.emplace<IntProduct>(token2_, value_ + 2);
0902 processBlock.put(token3_, std::make_unique<IntProduct>(value_ + 3));
0903 processBlock.put(token4_, std::make_unique<IntProduct>(value_ + 4));
0904 }
0905
0906
0907
0908
0909
0910 class TransientIntProducerEndProcessBlock : public edm::global::EDProducer<edm::EndProcessBlockProducer> {
0911 public:
0912 explicit TransientIntProducerEndProcessBlock(edm::ParameterSet const& p)
0913 : token_{produces<TransientIntProduct, edm::Transition::EndProcessBlock>()},
0914 value_(p.getParameter<int>("ivalue")) {}
0915 void produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {}
0916 void endProcessBlockProduce(edm::ProcessBlock&) override;
0917
0918 private:
0919 edm::EDPutTokenT<TransientIntProduct> token_;
0920 int value_;
0921 };
0922
0923 void TransientIntProducerEndProcessBlock::endProcessBlockProduce(edm::ProcessBlock& processBlock) {
0924 processBlock.emplace(token_, value_);
0925 }
0926
0927
0928
0929
0930 class MustRunIntProducer : public edm::global::EDProducer<> {
0931 public:
0932 explicit MustRunIntProducer(edm::ParameterSet const& p)
0933 : moduleLabel_{p.getParameter<std::string>("@module_label")},
0934 token_{produces<IntProduct>()},
0935 value_(p.getParameter<int>("ivalue")),
0936 produce_{p.getParameter<bool>("produce")},
0937 mustRunEvent_{p.getParameter<bool>("mustRunEvent")} {}
0938 ~MustRunIntProducer() {
0939 if (not wasRunEndJob_) {
0940 throw cms::Exception("NotRun") << "This module (" << moduleLabel_
0941 << ") should have run for endJob transition, but it did not";
0942 }
0943 }
0944 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0945 edm::ParameterSetDescription desc;
0946 desc.add<int>("ivalue");
0947 desc.add<bool>("produce", true);
0948 desc.add<bool>("mustRunEvent", true)
0949 ->setComment(
0950 "If set to false, the endJob() is still required to be called to check that the module was not deleted "
0951 "early on");
0952 descriptions.addDefault(desc);
0953 }
0954 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override {
0955 wasRunEvent_ = true;
0956 if (produce_) {
0957 e.emplace(token_, value_);
0958 }
0959 }
0960 void endJob() override {
0961 wasRunEndJob_ = true;
0962 if (mustRunEvent_ and not wasRunEvent_) {
0963 throw cms::Exception("NotRun") << "This module should have run for event transitions, but it did not";
0964 }
0965 }
0966
0967 private:
0968 const std::string moduleLabel_;
0969 const edm::EDPutTokenT<IntProduct> token_;
0970 const int value_;
0971 const bool produce_;
0972 const bool mustRunEvent_;
0973 mutable std::atomic<bool> wasRunEndJob_ = false;
0974 mutable std::atomic<bool> wasRunEvent_ = false;
0975 };
0976 }
0977
0978 namespace edm::test {
0979 namespace other {
0980 class IntProducer : public edm::global::EDProducer<> {
0981 public:
0982 explicit IntProducer(edm::ParameterSet const& p)
0983 : token_{produces()}, value_(p.getParameter<int>("valueOther")) {}
0984 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const final { e.emplace(token_, value_); }
0985
0986 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0987 edm::ParameterSetDescription desc;
0988 desc.add<int>("valueOther");
0989 desc.add<int>("valueCpu");
0990 desc.addUntracked<std::string>("variant", "");
0991
0992 descriptions.addWithDefaultLabel(desc);
0993 }
0994
0995 private:
0996 edm::EDPutTokenT<edmtest::IntProduct> token_;
0997 int value_;
0998 };
0999
1000 class IntTransformer : public edm::global::EDProducer<edm::Transformer> {
1001 public:
1002 explicit IntTransformer(edm::ParameterSet const& p)
1003 : token_{produces()}, value_(p.getParameter<int>("valueOther")) {
1004 registerTransform(token_, [](edm::StreamID, edmtest::ATransientIntProduct const& iV) {
1005 return edmtest::IntProduct(iV.value);
1006 });
1007 }
1008 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const final { e.emplace(token_, value_); }
1009
1010 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1011 edm::ParameterSetDescription desc;
1012 desc.add<int>("valueOther");
1013 desc.add<int>("valueCpu");
1014 desc.addUntracked<std::string>("variant", "");
1015
1016 descriptions.addWithDefaultLabel(desc);
1017 }
1018
1019 private:
1020 edm::EDPutTokenT<edmtest::ATransientIntProduct> token_;
1021 int value_;
1022 };
1023 }
1024 namespace cpu {
1025 class IntProducer : public edm::global::EDProducer<> {
1026 public:
1027 explicit IntProducer(edm::ParameterSet const& p) : token_{produces()}, value_(p.getParameter<int>("valueCpu")) {}
1028 void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const final { e.emplace(token_, value_); }
1029
1030 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1031 edm::ParameterSetDescription desc;
1032 desc.add<int>("valueOther");
1033 desc.add<int>("valueCpu");
1034 desc.addUntracked<std::string>("variant", "");
1035
1036 descriptions.addWithDefaultLabel(desc);
1037 }
1038
1039 private:
1040 edm::EDPutTokenT<edmtest::IntProduct> token_;
1041 int value_;
1042 };
1043
1044
1045
1046
1047
1048 using IntTransformer = IntProducer;
1049 }
1050 }
1051
1052 using edmtest::AddAllIntsProducer;
1053 using edmtest::AddIntsProducer;
1054 using edmtest::BusyWaitIntLimitedProducer;
1055 using edmtest::BusyWaitIntOneSharedProducer;
1056 using edmtest::BusyWaitIntProducer;
1057 using edmtest::ConsumingIntProducer;
1058 using edmtest::EventNumberIntProducer;
1059 using edmtest::FailingProducer;
1060 using edmtest::Int16_tProducer;
1061 using edmtest::IntOneSharedProducer;
1062 using edmtest::IntProducer;
1063 using edmtest::IntProducerBeginProcessBlock;
1064 using edmtest::IntProducerEndProcessBlock;
1065 using edmtest::IntProducerFromTransient;
1066 using edmtest::ManyIntProducer;
1067 using edmtest::ManyIntWhenRegisteredProducer;
1068 using edmtest::NonEventIntProducer;
1069 using edmtest::NonProducer;
1070 using edmtest::TransientIntProducer;
1071 using edmtest::TransientIntProducerEndProcessBlock;
1072 DEFINE_FWK_MODULE(FailingProducer);
1073 DEFINE_FWK_MODULE(edmtest::FailingInLumiProducer);
1074 DEFINE_FWK_MODULE(edmtest::FailingInRunProducer);
1075 DEFINE_FWK_MODULE(NonProducer);
1076 DEFINE_FWK_MODULE(IntProducer);
1077 DEFINE_FWK_MODULE(IntOneSharedProducer);
1078 DEFINE_FWK_MODULE(BusyWaitIntProducer);
1079 DEFINE_FWK_MODULE(BusyWaitIntLimitedProducer);
1080 DEFINE_FWK_MODULE(BusyWaitIntOneSharedProducer);
1081 DEFINE_FWK_MODULE(ConsumingIntProducer);
1082 DEFINE_FWK_MODULE(EventNumberIntProducer);
1083 DEFINE_FWK_MODULE(TransientIntProducer);
1084 DEFINE_FWK_MODULE(IntProducerFromTransient);
1085 DEFINE_FWK_MODULE(edmtest::TransientIntParentProducer);
1086 DEFINE_FWK_MODULE(edmtest::IntProducerFromTransientParent);
1087 DEFINE_FWK_MODULE(Int16_tProducer);
1088 DEFINE_FWK_MODULE(AddIntsProducer);
1089 DEFINE_FWK_MODULE(AddAllIntsProducer);
1090 DEFINE_FWK_MODULE(ManyIntProducer);
1091 DEFINE_FWK_MODULE(ManyIntWhenRegisteredProducer);
1092 DEFINE_FWK_MODULE(NonEventIntProducer);
1093 DEFINE_FWK_MODULE(IntProducerBeginProcessBlock);
1094 DEFINE_FWK_MODULE(IntProducerEndProcessBlock);
1095 DEFINE_FWK_MODULE(TransientIntProducerEndProcessBlock);
1096 DEFINE_FWK_MODULE(edmtest::MustRunIntProducer);
1097 DEFINE_FWK_MODULE(edm::test::other::IntProducer);
1098 DEFINE_FWK_MODULE(edm::test::cpu::IntProducer);
1099 DEFINE_FWK_MODULE(edm::test::other::IntTransformer);
1100 DEFINE_FWK_MODULE(edm::test::cpu::IntTransformer);