Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:12:19 

0001 
0002 /*----------------------------------------------------------------------
0003 
0004 Toy edm::limited::EDProducer modules of
0005 edm::*Cache templates and edm::*Producer classes
0006 for testing purposes only.
0007 
0008 ----------------------------------------------------------------------*/
0009 
0010 #include <atomic>
0011 #include <memory>
0012 #include <tuple>
0013 #include <vector>
0014 
0015 #include "DataFormats/TestObjects/interface/ToyProducts.h"
0016 #include "FWCore/Framework/interface/CacheHandle.h"
0017 #include "FWCore/Framework/interface/Event.h"
0018 #include "FWCore/Framework/interface/LuminosityBlock.h"
0019 #include "FWCore/Framework/interface/MakerMacros.h"
0020 #include "FWCore/Framework/interface/moduleAbilities.h"
0021 #include "FWCore/Framework/interface/limited/EDProducer.h"
0022 #include "FWCore/Framework/interface/ProcessBlock.h"
0023 #include "FWCore/Framework/interface/Run.h"
0024 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0025 #include "FWCore/Utilities/interface/BranchType.h"
0026 #include "FWCore/Utilities/interface/EDMException.h"
0027 #include "FWCore/Utilities/interface/EDGetToken.h"
0028 #include "FWCore/Utilities/interface/InputTag.h"
0029 
0030 namespace edmtest {
0031   namespace limited {
0032 
0033     namespace {
0034       struct Cache {
0035         Cache() : value(0), run(0), lumi(0), strm(0), work(0) {}
0036         //Using mutable since we want to update the value.
0037         mutable std::atomic<unsigned int> value;
0038         mutable std::atomic<unsigned int> run;
0039         mutable std::atomic<unsigned int> lumi;
0040         mutable std::atomic<unsigned int> strm;
0041         mutable std::atomic<unsigned int> work;
0042       };
0043 
0044       struct UnsafeCache {
0045         UnsafeCache() : value(0), run(0), lumi(0), strm(0), work(0) {}
0046         unsigned int value;
0047         unsigned int run;
0048         unsigned int lumi;
0049         unsigned int strm;
0050         unsigned int work;
0051       };
0052 
0053       struct Dummy {};
0054 
0055     }  //end anonymous namespace
0056 
0057     class StreamIntProducer : public edm::limited::EDProducer<edm::StreamCache<UnsafeCache>> {
0058     public:
0059       explicit StreamIntProducer(edm::ParameterSet const& p)
0060           : edm::limited::EDProducerBase(p),
0061             edm::limited::EDProducer<edm::StreamCache<UnsafeCache>>(p),
0062             trans_(p.getParameter<int>("transitions")),
0063             nLumis_(p.getUntrackedParameter<unsigned int>("nLumis", 1)) {
0064         produces<unsigned int>();
0065       }
0066 
0067       const unsigned int trans_;
0068       const unsigned int nLumis_;
0069       mutable std::atomic<unsigned int> m_count{0};
0070       mutable std::atomic<unsigned int> m_countStreams{0};
0071       mutable std::atomic<unsigned int> m_countStreamBeginLumiTransitions{0};
0072       mutable std::atomic<unsigned int> m_countStreamEndLumiTransitions{0};
0073 
0074       std::unique_ptr<UnsafeCache> beginStream(edm::StreamID iID) const override {
0075         ++m_count;
0076         ++m_countStreams;
0077         auto sCache = std::make_unique<UnsafeCache>();
0078         ++(sCache->strm);
0079         sCache->value = iID.value();
0080         return sCache;
0081       }
0082 
0083       void streamBeginRun(edm::StreamID iID, edm::Run const&, edm::EventSetup const&) const override {
0084         ++m_count;
0085         auto sCache = streamCache(iID);
0086         if (sCache->value != iID.value()) {
0087           throw cms::Exception("cache value")
0088               << "StreamIntProducer cache value " << (streamCache(iID))->value << " but it was supposed to be " << iID;
0089         }
0090         if (sCache->run != 0 || sCache->lumi != 0 || sCache->work != 0 || sCache->strm != 1) {
0091           throw cms::Exception("out of sequence") << "streamBeginRun out of sequence in Stream " << iID.value();
0092         }
0093         ++(sCache->run);
0094       }
0095 
0096       void streamBeginLuminosityBlock(edm::StreamID iID,
0097                                       edm::LuminosityBlock const&,
0098                                       edm::EventSetup const&) const override {
0099         ++m_countStreamBeginLumiTransitions;
0100         auto sCache = streamCache(iID);
0101         if (sCache->lumi != 0 || sCache->work != 0) {
0102           throw cms::Exception("out of sequence")
0103               << "streamBeginLuminosityBlock out of sequence in Stream " << iID.value();
0104         }
0105         ++(sCache->lumi);
0106       }
0107 
0108       void produce(edm::StreamID iID, edm::Event&, edm::EventSetup const&) const override {
0109         ++m_count;
0110         auto sCache = streamCache(iID);
0111         ++(sCache->work);
0112         if (sCache->lumi == 0 && sCache->run == 0) {
0113           throw cms::Exception("out of sequence") << "produce out of sequence in Stream " << iID.value();
0114         }
0115       }
0116 
0117       void streamEndLuminosityBlock(edm::StreamID iID,
0118                                     edm::LuminosityBlock const&,
0119                                     edm::EventSetup const&) const override {
0120         ++m_countStreamEndLumiTransitions;
0121         auto sCache = streamCache(iID);
0122         --(sCache->lumi);
0123         sCache->work = 0;
0124         if (sCache->lumi != 0 || sCache->run == 0) {
0125           throw cms::Exception("out of sequence")
0126               << "streamEndLuminosityBlock out of sequence in Stream " << iID.value();
0127         }
0128       }
0129 
0130       void streamEndRun(edm::StreamID iID, edm::Run const&, edm::EventSetup const&) const override {
0131         ++m_count;
0132         auto sCache = streamCache(iID);
0133         --(sCache->run);
0134         sCache->work = 0;
0135         if (sCache->run != 0 || sCache->lumi != 0) {
0136           throw cms::Exception("out of sequence") << "streamEndRun out of sequence in Stream " << iID.value();
0137         }
0138       }
0139 
0140       void endStream(edm::StreamID iID) const override {
0141         ++m_count;
0142         auto sCache = streamCache(iID);
0143         --(sCache->strm);
0144         if (sCache->strm != 0 || sCache->run != 0 || sCache->lumi != 0) {
0145           throw cms::Exception("out of sequence") << "endStream out of sequence in Stream " << iID.value();
0146         }
0147       }
0148 
0149       ~StreamIntProducer() {
0150         if (m_count != trans_) {
0151           throw cms::Exception("transitions")
0152               << "StreamIntProducer transitions " << m_count << " but it was supposed to be " << trans_;
0153         }
0154         unsigned int nStreamBeginLumiTransitions = m_countStreamBeginLumiTransitions.load();
0155         unsigned int nStreamEndLumiTransitions = m_countStreamEndLumiTransitions.load();
0156         unsigned int nStreams = m_countStreams.load();
0157         if (nStreamBeginLumiTransitions < nLumis_ || nStreamBeginLumiTransitions > (nLumis_ * nStreams)) {
0158           throw cms::Exception("transitions")
0159               << "StreamIntProducer stream begin lumi transitions " << nStreamBeginLumiTransitions
0160               << " but it was supposed to be between " << nLumis_ << " and " << nLumis_ * nStreams;
0161         }
0162         if (nStreamEndLumiTransitions != nStreamBeginLumiTransitions) {
0163           throw cms::Exception("transitions")
0164               << "StreamIntProducer stream end lumi transitions " << nStreamEndLumiTransitions
0165               << " does not equal stream begin lumi transitions " << nStreamBeginLumiTransitions;
0166         }
0167       }
0168     };
0169 
0170     class RunIntProducer : public edm::limited::EDProducer<edm::StreamCache<UnsafeCache>, edm::RunCache<Cache>> {
0171     public:
0172       explicit RunIntProducer(edm::ParameterSet const& p)
0173           : edm::limited::EDProducerBase(p),
0174             edm::limited::EDProducer<edm::StreamCache<UnsafeCache>, edm::RunCache<Cache>>(p),
0175             trans_(p.getParameter<int>("transitions")),
0176             cvalue_(p.getParameter<int>("cachevalue")) {
0177         produces<unsigned int>();
0178       }
0179 
0180       const unsigned int trans_;
0181       const unsigned int cvalue_;
0182       mutable std::atomic<unsigned int> m_count{0};
0183 
0184       std::shared_ptr<Cache> globalBeginRun(edm::Run const& iRun, edm::EventSetup const&) const override {
0185         ++m_count;
0186         auto rCache = std::make_shared<Cache>();
0187         ++(rCache->run);
0188         return rCache;
0189       }
0190 
0191       std::unique_ptr<UnsafeCache> beginStream(edm::StreamID) const override { return std::make_unique<UnsafeCache>(); }
0192 
0193       void streamBeginRun(edm::StreamID iID, edm::Run const& iRun, edm::EventSetup const&) const override {
0194         auto rCache = runCache(iRun.index());
0195         if (rCache->run == 0) {
0196           throw cms::Exception("out of sequence") << "streamBeginRun before globalBeginRun in Stream " << iID.value();
0197         }
0198       }
0199 
0200       void produce(edm::StreamID iID, edm::Event& iEvent, edm::EventSetup const&) const override {
0201         auto rCache = runCache(iEvent.getRun().index());
0202         ++(rCache->value);
0203       }
0204 
0205       void streamEndRun(edm::StreamID iID, edm::Run const& iRun, edm::EventSetup const&) const override {
0206         auto rCache = runCache(iRun.index());
0207         if (rCache->run == 0) {
0208           throw cms::Exception("out of sequence") << "streamEndRun after globalEndRun in Stream " << iID.value();
0209         }
0210       }
0211 
0212       void globalEndRun(edm::Run const& iRun, edm::EventSetup const&) const override {
0213         ++m_count;
0214         auto rCache = runCache(iRun.index());
0215         if (rCache->value != cvalue_) {
0216           throw cms::Exception("cache value")
0217               << "RunIntProducer cache value " << rCache->value << " but it was supposed to be " << cvalue_;
0218         }
0219         --(rCache->run);
0220       }
0221 
0222       ~RunIntProducer() {
0223         if (m_count != trans_) {
0224           throw cms::Exception("transitions")
0225               << "RunIntProducer transitions " << m_count << " but it was supposed to be " << trans_;
0226         }
0227       }
0228     };
0229 
0230     class LumiIntProducer
0231         : public edm::limited::EDProducer<edm::StreamCache<UnsafeCache>, edm::LuminosityBlockCache<Cache>> {
0232     public:
0233       explicit LumiIntProducer(edm::ParameterSet const& p)
0234           : edm::limited::EDProducerBase(p),
0235             edm::limited::EDProducer<edm::StreamCache<UnsafeCache>, edm::LuminosityBlockCache<Cache>>(p),
0236             trans_(p.getParameter<int>("transitions")),
0237             cvalue_(p.getParameter<int>("cachevalue")) {
0238         produces<unsigned int>();
0239       }
0240       const unsigned int trans_;
0241       const unsigned int cvalue_;
0242       mutable std::atomic<unsigned int> m_count{0};
0243 
0244       std::shared_ptr<Cache> globalBeginLuminosityBlock(edm::LuminosityBlock const& iLB,
0245                                                         edm::EventSetup const&) const override {
0246         ++m_count;
0247         auto lCache = std::make_shared<Cache>();
0248         ++(lCache->lumi);
0249         return lCache;
0250       }
0251 
0252       std::unique_ptr<UnsafeCache> beginStream(edm::StreamID) const override { return std::make_unique<UnsafeCache>(); }
0253 
0254       void streamBeginLuminosityBlock(edm::StreamID iID,
0255                                       edm::LuminosityBlock const& iLB,
0256                                       edm::EventSetup const&) const override {
0257         auto lCache = luminosityBlockCache(iLB.index());
0258         if (lCache->lumi == 0) {
0259           throw cms::Exception("out of sequence")
0260               << "streamBeginLuminosityBlock seen before globalBeginLuminosityBlock in LuminosityBlock"
0261               << iLB.luminosityBlock();
0262         }
0263       }
0264 
0265       void produce(edm::StreamID, edm::Event& iEvent, edm::EventSetup const&) const override {
0266         auto lCache = luminosityBlockCache(iEvent.getLuminosityBlock().index());
0267         ++(lCache->value);
0268       }
0269 
0270       void streamEndLuminosityBlock(edm::StreamID iID,
0271                                     edm::LuminosityBlock const& iLB,
0272                                     edm::EventSetup const&) const override {
0273         auto lCache = luminosityBlockCache(iLB.index());
0274         if (lCache->lumi == 0) {
0275           throw cms::Exception("out of sequence")
0276               << "streamEndLuminosityBlock seen before globalEndLuminosityBlock in LuminosityBlock"
0277               << iLB.luminosityBlock();
0278         }
0279       }
0280 
0281       void globalEndLuminosityBlock(edm::LuminosityBlock const& iLB, edm::EventSetup const&) const override {
0282         ++m_count;
0283         auto lCache = luminosityBlockCache(iLB.index());
0284         --(lCache->lumi);
0285         if (lCache->lumi != 0) {
0286           throw cms::Exception("end out of sequence")
0287               << "globalEndLuminosityBlock seen before globalBeginLuminosityBlock in LuminosityBlock"
0288               << iLB.luminosityBlock();
0289         }
0290         if (lCache->value != cvalue_) {
0291           throw cms::Exception("cache value")
0292               << "LumiIntProducer cache value " << lCache->value << " but it was supposed to be " << cvalue_;
0293         }
0294       }
0295 
0296       ~LumiIntProducer() {
0297         if (m_count != trans_) {
0298           throw cms::Exception("transitions")
0299               << "LumiIntProducer transitions " << m_count << " but it was supposed to be " << trans_;
0300         }
0301       }
0302     };
0303 
0304     class RunSummaryIntProducer
0305         : public edm::limited::EDProducer<edm::StreamCache<UnsafeCache>, edm::RunSummaryCache<UnsafeCache>> {
0306     public:
0307       explicit RunSummaryIntProducer(edm::ParameterSet const& p)
0308           : edm::limited::EDProducerBase(p),
0309             edm::limited::EDProducer<edm::StreamCache<UnsafeCache>, edm::RunSummaryCache<UnsafeCache>>(p),
0310             trans_(p.getParameter<int>("transitions")),
0311             cvalue_(p.getParameter<int>("cachevalue")) {
0312         produces<unsigned int>();
0313       }
0314       const unsigned int trans_;
0315       const unsigned int cvalue_;
0316       mutable std::atomic<unsigned int> m_count{0};
0317 
0318       std::unique_ptr<UnsafeCache> beginStream(edm::StreamID) const override { return std::make_unique<UnsafeCache>(); }
0319 
0320       std::shared_ptr<UnsafeCache> globalBeginRunSummary(edm::Run const& iRun, edm::EventSetup const&) const override {
0321         ++m_count;
0322         auto gCache = std::make_shared<UnsafeCache>();
0323         ++(gCache->run);
0324         return gCache;
0325       }
0326 
0327       void produce(edm::StreamID iID, edm::Event&, edm::EventSetup const&) const override {
0328         auto sCache = streamCache(iID);
0329         ++(sCache->value);
0330       }
0331 
0332       void streamEndRunSummary(edm::StreamID iID,
0333                                edm::Run const&,
0334                                edm::EventSetup const&,
0335                                UnsafeCache* gCache) const override {
0336         ++m_count;
0337         if (gCache->run == 0) {
0338           throw cms::Exception("out of sequence")
0339               << "streamEndRunSummary after globalEndRunSummary in Stream " << iID.value();
0340         }
0341         auto sCache = streamCache(iID);
0342         gCache->value += sCache->value;
0343         sCache->value = 0;
0344       }
0345 
0346       void globalEndRunSummary(edm::Run const&, edm::EventSetup const&, UnsafeCache* gCache) const override {
0347         ++m_count;
0348         if (gCache->value != cvalue_) {
0349           throw cms::Exception("cache value")
0350               << "RunSummaryIntProducer cache value " << gCache->value << " but it was supposed to be " << cvalue_;
0351         }
0352         --(gCache->run);
0353       }
0354 
0355       ~RunSummaryIntProducer() {
0356         if (m_count != trans_) {
0357           throw cms::Exception("transitions")
0358               << "RunSummaryIntProducer transitions " << m_count << " but it was supposed to be " << trans_;
0359         }
0360       }
0361     };
0362 
0363     class LumiSummaryIntProducer
0364         : public edm::limited::EDProducer<edm::StreamCache<UnsafeCache>, edm::LuminosityBlockSummaryCache<UnsafeCache>> {
0365     public:
0366       explicit LumiSummaryIntProducer(edm::ParameterSet const& p)
0367           : edm::limited::EDProducerBase(p),
0368             edm::limited::EDProducer<edm::StreamCache<UnsafeCache>, edm::LuminosityBlockSummaryCache<UnsafeCache>>(p),
0369             trans_(p.getParameter<int>("transitions")),
0370             cvalue_(p.getParameter<int>("cachevalue")) {
0371         produces<unsigned int>();
0372       }
0373       const unsigned int trans_;
0374       const unsigned int cvalue_;
0375       mutable std::atomic<unsigned int> m_count{0};
0376       mutable std::atomic<unsigned int> m_countLumis{0};
0377       mutable std::atomic<unsigned int> m_countStreams{0};
0378       mutable std::atomic<unsigned int> m_countStreamLumiTransitions{0};
0379 
0380       std::unique_ptr<UnsafeCache> beginStream(edm::StreamID) const override {
0381         ++m_count;
0382         ++m_countStreams;
0383         return std::make_unique<UnsafeCache>();
0384       }
0385 
0386       std::shared_ptr<UnsafeCache> globalBeginLuminosityBlockSummary(edm::LuminosityBlock const& iLB,
0387                                                                      edm::EventSetup const&) const override {
0388         ++m_count;
0389         ++m_countLumis;
0390         auto gCache = std::make_shared<UnsafeCache>();
0391         gCache->lumi = iLB.luminosityBlockAuxiliary().luminosityBlock();
0392         return gCache;
0393       }
0394 
0395       void produce(edm::StreamID iID, edm::Event&, edm::EventSetup const&) const override {
0396         ++m_count;
0397         auto sCache = streamCache(iID);
0398         ++(sCache->value);
0399       }
0400 
0401       void streamEndLuminosityBlockSummary(edm::StreamID iID,
0402                                            edm::LuminosityBlock const& iLB,
0403                                            edm::EventSetup const&,
0404                                            UnsafeCache* gCache) const override {
0405         ++m_countStreamLumiTransitions;
0406         if (gCache->lumi != iLB.luminosityBlockAuxiliary().luminosityBlock()) {
0407           throw cms::Exception("UnexpectedValue")
0408               << "streamEndLuminosityBlockSummary unexpected lumi number in Stream " << iID.value();
0409         }
0410         auto sCache = streamCache(iID);
0411         gCache->value += sCache->value;
0412         sCache->value = 0;
0413       }
0414 
0415       void globalEndLuminosityBlockSummary(edm::LuminosityBlock const& iLB,
0416                                            edm::EventSetup const&,
0417                                            UnsafeCache* gCache) const override {
0418         ++m_count;
0419         if (gCache->lumi != iLB.luminosityBlockAuxiliary().luminosityBlock()) {
0420           throw cms::Exception("UnexpectedValue") << "globalEndLuminosityBlockSummary unexpected lumi number";
0421         }
0422         if (gCache->value != cvalue_) {
0423           throw cms::Exception("cache value")
0424               << "LumiSummaryIntProducer cache value " << gCache->value << " but it was supposed to be " << cvalue_;
0425         }
0426       }
0427 
0428       ~LumiSummaryIntProducer() {
0429         if (m_count != trans_) {
0430           throw cms::Exception("transitions")
0431               << "LumiSummaryIntProducer transitions " << m_count << " but it was supposed to be " << trans_;
0432         }
0433         unsigned int nStreamLumiTransitions = m_countStreamLumiTransitions.load();
0434         unsigned int nLumis = m_countLumis.load();
0435         unsigned int nStreams = m_countStreams.load();
0436         if (nStreamLumiTransitions < nLumis || nStreamLumiTransitions > (nLumis * nStreams)) {
0437           throw cms::Exception("transitions")
0438               << "LumiSummaryIntProducer stream lumi transitions " << nStreamLumiTransitions
0439               << " but it was supposed to be between " << nLumis << " and " << nLumis * nStreams;
0440         }
0441       }
0442     };
0443 
0444     class LumiSummaryLumiProducer : public edm::limited::EDProducer<edm::StreamCache<UnsafeCache>,
0445                                                                     edm::LuminosityBlockSummaryCache<UnsafeCache>,
0446                                                                     edm::EndLuminosityBlockProducer> {
0447     public:
0448       explicit LumiSummaryLumiProducer(edm::ParameterSet const& p)
0449           : edm::limited::EDProducerBase(p),
0450             edm::limited::EDProducer<edm::StreamCache<UnsafeCache>,
0451                                      edm::LuminosityBlockSummaryCache<UnsafeCache>,
0452                                      edm::EndLuminosityBlockProducer>(p),
0453             trans_(p.getParameter<int>("transitions")),
0454             cvalue_(p.getParameter<int>("cachevalue")) {
0455         produces<unsigned int>();
0456       }
0457       const unsigned int trans_;
0458       const unsigned int cvalue_;
0459       mutable std::atomic<unsigned int> m_count{0};
0460       mutable std::atomic<unsigned int> m_countLumis{0};
0461       mutable std::atomic<unsigned int> m_countStreams{0};
0462       mutable std::atomic<unsigned int> m_countStreamLumiTransitions{0};
0463 
0464       std::unique_ptr<UnsafeCache> beginStream(edm::StreamID) const override {
0465         ++m_count;
0466         ++m_countStreams;
0467         return std::make_unique<UnsafeCache>();
0468       }
0469 
0470       std::shared_ptr<UnsafeCache> globalBeginLuminosityBlockSummary(edm::LuminosityBlock const& iLB,
0471                                                                      edm::EventSetup const&) const override {
0472         ++m_count;
0473         ++m_countLumis;
0474         auto gCache = std::make_shared<UnsafeCache>();
0475         gCache->lumi = iLB.luminosityBlockAuxiliary().luminosityBlock();
0476         return gCache;
0477       }
0478 
0479       void produce(edm::StreamID iID, edm::Event&, edm::EventSetup const&) const override {
0480         auto sCache = streamCache(iID);
0481         ++(sCache->value);
0482       }
0483 
0484       void streamEndLuminosityBlockSummary(edm::StreamID iID,
0485                                            edm::LuminosityBlock const& iLB,
0486                                            edm::EventSetup const&,
0487                                            UnsafeCache* gCache) const override {
0488         ++m_countStreamLumiTransitions;
0489         if (gCache->lumi != iLB.luminosityBlockAuxiliary().luminosityBlock()) {
0490           throw cms::Exception("UnexpectedValue")
0491               << "streamEndLuminosityBlockSummary unexpected lumi number in Stream " << iID.value();
0492         }
0493         auto sCache = streamCache(iID);
0494         gCache->value += sCache->value;
0495         sCache->value = 0;
0496       }
0497 
0498       void globalEndLuminosityBlockSummary(edm::LuminosityBlock const& iLB,
0499                                            edm::EventSetup const&,
0500                                            UnsafeCache* gCache) const override {
0501         ++m_count;
0502         if (gCache->lumi != iLB.luminosityBlockAuxiliary().luminosityBlock()) {
0503           throw cms::Exception("UnexpectedValue") << "globalEndLuminosityBlockSummary unexpected lumi number";
0504         }
0505         if (gCache->value != cvalue_) {
0506           throw cms::Exception("cache value")
0507               << "LumiSummaryLumiProducer cache value " << gCache->value << " but it was supposed to be " << cvalue_;
0508         }
0509       }
0510 
0511       void globalEndLuminosityBlockProduce(edm::LuminosityBlock& iLB,
0512                                            edm::EventSetup const&,
0513                                            UnsafeCache const* gCache) const override {
0514         ++m_count;
0515         if (gCache->lumi != iLB.luminosityBlockAuxiliary().luminosityBlock()) {
0516           throw cms::Exception("UnexpectedValue") << "globalEndLuminosityBlockProduce unexpected lumi number";
0517         }
0518       }
0519 
0520       ~LumiSummaryLumiProducer() {
0521         if (m_count != trans_) {
0522           throw cms::Exception("transitions")
0523               << "LumiSummaryLumiProducer transitions " << m_count << " but it was supposed to be " << trans_;
0524         }
0525         unsigned int nStreamLumiTransitions = m_countStreamLumiTransitions.load();
0526         unsigned int nLumis = m_countLumis.load();
0527         unsigned int nStreams = m_countStreams.load();
0528         if (nStreamLumiTransitions < nLumis || nStreamLumiTransitions > (nLumis * nStreams)) {
0529           throw cms::Exception("transitions")
0530               << "LumiSummaryLumiProducer stream lumi transitions " << nStreamLumiTransitions
0531               << " but it was supposed to be between " << nLumis << " and " << nLumis * nStreams;
0532         }
0533       }
0534     };
0535 
0536     class ProcessBlockIntProducer : public edm::limited::EDProducer<edm::WatchProcessBlock> {
0537     public:
0538       explicit ProcessBlockIntProducer(edm::ParameterSet const& pset)
0539           : edm::limited::EDProducerBase(pset),
0540             edm::limited::EDProducer<edm::WatchProcessBlock>(pset),
0541             trans_(pset.getParameter<int>("transitions")) {
0542         produces<unsigned int>();
0543 
0544         {
0545           auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlock");
0546           if (not tag.label().empty()) {
0547             getTokenBegin_ = consumes<unsigned int, edm::InProcess>(tag);
0548           }
0549         }
0550         {
0551           auto tag = pset.getParameter<edm::InputTag>("consumesEndProcessBlock");
0552           if (not tag.label().empty()) {
0553             getTokenEnd_ = consumes<unsigned int, edm::InProcess>(tag);
0554           }
0555         }
0556       }
0557 
0558       void beginProcessBlock(edm::ProcessBlock const& processBlock) override {
0559         if (m_count != 0) {
0560           throw cms::Exception("transitions")
0561               << "ProcessBlockIntProducer::begin transitions " << m_count << " but it was supposed to be " << 0;
0562         }
0563         ++m_count;
0564         const unsigned int valueToGet = 11;
0565         if (not getTokenBegin_.isUninitialized()) {
0566           if (processBlock.get(getTokenBegin_) != valueToGet) {
0567             throw cms::Exception("BadValue")
0568                 << "expected " << valueToGet << " but got " << processBlock.get(getTokenBegin_);
0569           }
0570         }
0571       }
0572 
0573       void produce(edm::StreamID iID, edm::Event&, edm::EventSetup const&) const override {
0574         if (m_count < 1u) {
0575           throw cms::Exception("out of sequence") << "produce before beginProcessBlock " << m_count;
0576         }
0577         ++m_count;
0578       }
0579 
0580       void endProcessBlock(edm::ProcessBlock const& processBlock) override {
0581         ++m_count;
0582         if (m_count != trans_) {
0583           throw cms::Exception("transitions")
0584               << "ProcessBlockIntProducer::end transitions " << m_count << " but it was supposed to be " << trans_;
0585         }
0586         {
0587           const unsigned int valueToGet = 11;
0588           if (not getTokenBegin_.isUninitialized()) {
0589             if (processBlock.get(getTokenBegin_) != valueToGet) {
0590               throw cms::Exception("BadValue")
0591                   << "expected " << valueToGet << " but got " << processBlock.get(getTokenBegin_);
0592             }
0593           }
0594         }
0595         {
0596           const unsigned int valueToGet = 21;
0597           if (not getTokenEnd_.isUninitialized()) {
0598             if (processBlock.get(getTokenEnd_) != valueToGet) {
0599               throw cms::Exception("BadValue")
0600                   << "expected " << valueToGet << " but got " << processBlock.get(getTokenEnd_);
0601             }
0602           }
0603         }
0604       }
0605 
0606       ~ProcessBlockIntProducer() {
0607         if (m_count != trans_) {
0608           throw cms::Exception("transitions")
0609               << "ProcessBlockIntProducer transitions " << m_count << " but it was supposed to be " << trans_;
0610         }
0611       }
0612 
0613     private:
0614       const unsigned int trans_;
0615       mutable std::atomic<unsigned int> m_count{0};
0616       edm::EDGetTokenT<unsigned int> getTokenBegin_;
0617       edm::EDGetTokenT<unsigned int> getTokenEnd_;
0618     };
0619 
0620     class TestBeginProcessBlockProducer : public edm::limited::EDProducer<edm::BeginProcessBlockProducer> {
0621     public:
0622       explicit TestBeginProcessBlockProducer(edm::ParameterSet const& pset)
0623           : edm::limited::EDProducerBase(pset),
0624             edm::limited::EDProducer<edm::BeginProcessBlockProducer>(pset),
0625             trans_(pset.getParameter<int>("transitions")),
0626             token_(produces<unsigned int, edm::Transition::BeginProcessBlock>("begin")) {
0627         produces<unsigned int>();
0628 
0629         auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlock");
0630         if (not tag.label().empty()) {
0631           getToken_ = consumes<unsigned int, edm::InProcess>(tag);
0632         }
0633       }
0634 
0635       void beginProcessBlockProduce(edm::ProcessBlock& processBlock) override {
0636         if (m_count != 0) {
0637           throw cms::Exception("transitions")
0638               << "TestBeginProcessBlockProducer transitions " << m_count << " but it was supposed to be " << 0;
0639         }
0640         ++m_count;
0641 
0642         const unsigned int valueToPutAndGet = 11;
0643         processBlock.emplace(token_, valueToPutAndGet);
0644 
0645         if (not getToken_.isUninitialized()) {
0646           if (processBlock.get(getToken_) != valueToPutAndGet) {
0647             throw cms::Exception("BadValue")
0648                 << "expected " << valueToPutAndGet << " but got " << processBlock.get(getToken_);
0649           }
0650         }
0651       }
0652 
0653       void produce(edm::StreamID iID, edm::Event&, edm::EventSetup const&) const override {
0654         if (m_count < 1u) {
0655           throw cms::Exception("out of sequence") << "produce before beginProcessBlockProduce " << m_count;
0656         }
0657         ++m_count;
0658       }
0659 
0660       ~TestBeginProcessBlockProducer() {
0661         if (m_count != trans_) {
0662           throw cms::Exception("transitions")
0663               << "TestBeginProcessBlockProducer transitions " << m_count << " but it was supposed to be " << trans_;
0664         }
0665       }
0666 
0667     private:
0668       const unsigned int trans_;
0669       mutable std::atomic<unsigned int> m_count{0};
0670       edm::EDPutTokenT<unsigned int> token_;
0671       edm::EDGetTokenT<unsigned int> getToken_;
0672     };
0673 
0674     class TestEndProcessBlockProducer : public edm::limited::EDProducer<edm::EndProcessBlockProducer> {
0675     public:
0676       explicit TestEndProcessBlockProducer(edm::ParameterSet const& pset)
0677           : edm::limited::EDProducerBase(pset),
0678             edm::limited::EDProducer<edm::EndProcessBlockProducer>(pset),
0679             trans_(pset.getParameter<int>("transitions")),
0680             token_(produces<unsigned int, edm::Transition::EndProcessBlock>("end")) {
0681         produces<unsigned int>();
0682 
0683         auto tag = pset.getParameter<edm::InputTag>("consumesEndProcessBlock");
0684         if (not tag.label().empty()) {
0685           getToken_ = consumes<unsigned int, edm::InProcess>(tag);
0686         }
0687       }
0688 
0689       void produce(edm::StreamID iID, edm::Event&, edm::EventSetup const&) const override { ++m_count; }
0690 
0691       void endProcessBlockProduce(edm::ProcessBlock& processBlock) override {
0692         ++m_count;
0693         if (m_count != trans_) {
0694           throw cms::Exception("transitions")
0695               << "TestEndProcessBlockProducer transitions " << m_count << " but it was supposed to be " << trans_;
0696         }
0697 
0698         const unsigned int valueToPutAndGet = 21;
0699         processBlock.emplace(token_, valueToPutAndGet);
0700         if (not getToken_.isUninitialized()) {
0701           if (processBlock.get(getToken_) != valueToPutAndGet) {
0702             throw cms::Exception("BadValue")
0703                 << "expected " << valueToPutAndGet << " but got " << processBlock.get(getToken_);
0704           }
0705         }
0706       }
0707 
0708       ~TestEndProcessBlockProducer() {
0709         if (m_count != trans_) {
0710           throw cms::Exception("transitions")
0711               << "~TestEndProcessBlockProducer transitions " << m_count << " but it was supposed to be " << trans_;
0712         }
0713       }
0714 
0715     private:
0716       const unsigned int trans_;
0717       mutable std::atomic<unsigned int> m_count{0};
0718       edm::EDPutTokenT<unsigned int> token_;
0719       edm::EDGetTokenT<unsigned int> getToken_;
0720     };
0721 
0722     class TestBeginRunProducer : public edm::limited::EDProducer<edm::RunCache<Dummy>, edm::BeginRunProducer> {
0723     public:
0724       explicit TestBeginRunProducer(edm::ParameterSet const& p)
0725           : edm::limited::EDProducerBase(p),
0726             edm::limited::EDProducer<edm::RunCache<Dummy>, edm::BeginRunProducer>(p),
0727             trans_(p.getParameter<int>("transitions")) {
0728         produces<unsigned int>();
0729         produces<unsigned int, edm::Transition::BeginRun>("a");
0730       }
0731 
0732       const unsigned int trans_;
0733       mutable std::atomic<unsigned int> m_count{0};
0734       mutable std::atomic<bool> brp{false};
0735 
0736       std::shared_ptr<Dummy> globalBeginRun(edm::Run const& iRun, edm::EventSetup const&) const override {
0737         brp = false;
0738         return std::shared_ptr<Dummy>();
0739       }
0740 
0741       void produce(edm::StreamID iID, edm::Event&, edm::EventSetup const&) const override {
0742         if (!brp) {
0743           throw cms::Exception("out of sequence") << "produce before globalBeginRunProduce in Stream " << iID.value();
0744         }
0745       }
0746 
0747       void globalBeginRunProduce(edm::Run&, edm::EventSetup const&) const override {
0748         ++m_count;
0749         brp = true;
0750       }
0751 
0752       void globalEndRun(edm::Run const& iRun, edm::EventSetup const&) const override {}
0753 
0754       ~TestBeginRunProducer() {
0755         if (m_count != trans_) {
0756           throw cms::Exception("transitions")
0757               << "TestBeginRunProducer transitions " << m_count << " but it was supposed to be " << trans_;
0758         }
0759       }
0760     };
0761 
0762     class TestEndRunProducer : public edm::limited::EDProducer<edm::RunCache<Dummy>, edm::EndRunProducer> {
0763     public:
0764       explicit TestEndRunProducer(edm::ParameterSet const& p)
0765           : edm::limited::EDProducerBase(p),
0766             edm::limited::EDProducer<edm::RunCache<Dummy>, edm::EndRunProducer>(p),
0767             trans_(p.getParameter<int>("transitions")) {
0768         produces<unsigned int>();
0769         produces<unsigned int, edm::Transition::EndRun>("a");
0770       }
0771       const unsigned int trans_;
0772       mutable std::atomic<unsigned int> m_count{0};
0773       mutable std::atomic<bool> p{false};
0774 
0775       std::shared_ptr<Dummy> globalBeginRun(edm::Run const& iRun, edm::EventSetup const&) const override {
0776         p = false;
0777         return std::shared_ptr<Dummy>();
0778       }
0779 
0780       void produce(edm::StreamID iID, edm::Event&, edm::EventSetup const&) const override { p = true; }
0781 
0782       void globalEndRunProduce(edm::Run&, edm::EventSetup const&) const override {
0783         if (!p) {
0784           throw cms::Exception("out of sequence") << "endRunProduce before produce";
0785         }
0786         ++m_count;
0787       }
0788 
0789       void globalEndRun(edm::Run const& iRun, edm::EventSetup const&) const override {}
0790 
0791       ~TestEndRunProducer() {
0792         if (m_count != trans_) {
0793           throw cms::Exception("transitions")
0794               << "TestEndRunProducer transitions " << m_count << " but it was supposed to be " << trans_;
0795         }
0796       }
0797     };
0798 
0799     class TestBeginLumiBlockProducer
0800         : public edm::limited::EDProducer<edm::LuminosityBlockCache<void>, edm::BeginLuminosityBlockProducer> {
0801     public:
0802       explicit TestBeginLumiBlockProducer(edm::ParameterSet const& p)
0803           : edm::limited::EDProducerBase(p),
0804             edm::limited::EDProducer<edm::LuminosityBlockCache<void>, edm::BeginLuminosityBlockProducer>(p),
0805             trans_(p.getParameter<int>("transitions")) {
0806         produces<unsigned int>();
0807         produces<unsigned int, edm::Transition::BeginLuminosityBlock>("a");
0808       }
0809       const unsigned int trans_;
0810       mutable std::atomic<unsigned int> m_count{0};
0811       mutable std::atomic<bool> gblp{false};
0812 
0813       std::shared_ptr<void> globalBeginLuminosityBlock(edm::LuminosityBlock const& iLB,
0814                                                        edm::EventSetup const&) const override {
0815         gblp = false;
0816         return std::shared_ptr<void>();
0817       }
0818 
0819       void produce(edm::StreamID iID, edm::Event&, const edm::EventSetup&) const override {
0820         if (!gblp) {
0821           throw cms::Exception("out of sequence")
0822               << "produce before globalBeginLuminosityBlockProduce in Stream " << iID.value();
0823         }
0824       }
0825 
0826       void globalBeginLuminosityBlockProduce(edm::LuminosityBlock&, edm::EventSetup const&) const override {
0827         ++m_count;
0828         gblp = true;
0829       }
0830 
0831       void globalEndLuminosityBlock(edm::LuminosityBlock const& iLB, edm::EventSetup const&) const override {}
0832 
0833       ~TestBeginLumiBlockProducer() {
0834         if (m_count != trans_) {
0835           throw cms::Exception("transitions")
0836               << "TestBeginLumiBlockProducer transitions " << m_count << " but it was supposed to be " << trans_;
0837         }
0838       }
0839     };
0840 
0841     class TestEndLumiBlockProducer
0842         : public edm::limited::EDProducer<edm::LuminosityBlockCache<void>, edm::EndLuminosityBlockProducer> {
0843     public:
0844       explicit TestEndLumiBlockProducer(edm::ParameterSet const& p)
0845           : edm::limited::EDProducerBase(p),
0846             edm::limited::EDProducer<edm::LuminosityBlockCache<void>, edm::EndLuminosityBlockProducer>(p),
0847             trans_(p.getParameter<int>("transitions")) {
0848         produces<unsigned int>();
0849         produces<unsigned int, edm::Transition::EndLuminosityBlock>("a");
0850       }
0851       const unsigned int trans_;
0852       mutable std::atomic<unsigned int> m_count{0};
0853       mutable std::atomic<bool> p{false};
0854 
0855       std::shared_ptr<void> globalBeginLuminosityBlock(edm::LuminosityBlock const& iLB,
0856                                                        edm::EventSetup const&) const override {
0857         p = false;
0858         return std::shared_ptr<void>();
0859       }
0860 
0861       void produce(edm::StreamID iID, edm::Event&, edm::EventSetup const&) const override { p = true; }
0862 
0863       void globalEndLuminosityBlockProduce(edm::LuminosityBlock&, edm::EventSetup const&) const override {
0864         if (!p) {
0865           throw cms::Exception("out of sequence") << "endLumiBlockProduce before produce";
0866         }
0867         ++m_count;
0868       }
0869 
0870       void globalEndLuminosityBlock(edm::LuminosityBlock const& iLB, edm::EventSetup const&) const override {}
0871 
0872       ~TestEndLumiBlockProducer() {
0873         if (m_count != trans_) {
0874           throw cms::Exception("transitions")
0875               << "TestEndLumiBlockProducer transitions " << m_count << " but it was supposed to be " << trans_;
0876         }
0877       }
0878     };
0879 
0880     class TestAccumulator : public edm::limited::EDProducer<edm::Accumulator, edm::EndLuminosityBlockProducer> {
0881     public:
0882       explicit TestAccumulator(edm::ParameterSet const& p)
0883           : edm::limited::EDProducerBase(p),
0884             edm::limited::EDProducer<edm::Accumulator, edm::EndLuminosityBlockProducer>(p),
0885             m_expectedCount(p.getParameter<unsigned int>("expectedCount")),
0886             m_putToken(produces<unsigned int, edm::Transition::EndLuminosityBlock>()) {}
0887 
0888       void accumulate(edm::StreamID iID, edm::Event const&, edm::EventSetup const&) const override { ++m_count; }
0889 
0890       void globalEndLuminosityBlockProduce(edm::LuminosityBlock& l, edm::EventSetup const&) const override {
0891         l.emplace(m_putToken, m_count.load());
0892       }
0893 
0894       ~TestAccumulator() {
0895         if (m_count.load() != m_expectedCount) {
0896           throw cms::Exception("TestCount")
0897               << "TestAccumulator counter was " << m_count << " but it was supposed to be " << m_expectedCount;
0898         }
0899       }
0900 
0901       mutable std::atomic<unsigned int> m_count{0};
0902       const unsigned int m_expectedCount;
0903       const edm::EDPutTokenT<unsigned int> m_putToken;
0904     };
0905 
0906     class TestInputProcessBlockCache {
0907     public:
0908       long long int value_ = 0;
0909     };
0910 
0911     class TestInputProcessBlockCache1 {
0912     public:
0913       long long int value_ = 0;
0914     };
0915 
0916     class InputProcessBlockIntProducer
0917         : public edm::limited::EDProducer<
0918               edm::InputProcessBlockCache<int, TestInputProcessBlockCache, TestInputProcessBlockCache1>> {
0919     public:
0920       explicit InputProcessBlockIntProducer(edm::ParameterSet const& pset)
0921           : edm::limited::EDProducerBase(pset),
0922             edm::limited::EDProducer<
0923                 edm::InputProcessBlockCache<int, TestInputProcessBlockCache, TestInputProcessBlockCache1>>(pset) {
0924         expectedTransitions_ = pset.getParameter<int>("transitions");
0925         expectedByRun_ = pset.getParameter<std::vector<int>>("expectedByRun");
0926         expectedSum_ = pset.getParameter<int>("expectedSum");
0927         {
0928           auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlock");
0929           if (not tag.label().empty()) {
0930             getTokenBegin_ = consumes<IntProduct, edm::InProcess>(tag);
0931           }
0932         }
0933         {
0934           auto tag = pset.getParameter<edm::InputTag>("consumesEndProcessBlock");
0935           if (not tag.label().empty()) {
0936             getTokenEnd_ = consumes<IntProduct, edm::InProcess>(tag);
0937           }
0938         }
0939         {
0940           auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlockM");
0941           if (not tag.label().empty()) {
0942             getTokenBeginM_ = consumes<IntProduct, edm::InProcess>(tag);
0943           }
0944         }
0945         {
0946           auto tag = pset.getParameter<edm::InputTag>("consumesEndProcessBlockM");
0947           if (not tag.label().empty()) {
0948             getTokenEndM_ = consumes<IntProduct, edm::InProcess>(tag);
0949           }
0950         }
0951         registerProcessBlockCacheFiller<int>(
0952             getTokenBegin_, [this](edm::ProcessBlock const& processBlock, std::shared_ptr<int> const& previousCache) {
0953               auto returnValue = std::make_shared<int>(0);
0954               *returnValue += processBlock.get(getTokenBegin_).value;
0955               *returnValue += processBlock.get(getTokenEnd_).value;
0956               ++transitions_;
0957               return returnValue;
0958             });
0959         registerProcessBlockCacheFiller<1>(getTokenBegin_,
0960                                            [this](edm::ProcessBlock const& processBlock,
0961                                                   std::shared_ptr<TestInputProcessBlockCache> const& previousCache) {
0962                                              auto returnValue = std::make_shared<TestInputProcessBlockCache>();
0963                                              returnValue->value_ += processBlock.get(getTokenBegin_).value;
0964                                              returnValue->value_ += processBlock.get(getTokenEnd_).value;
0965                                              ++transitions_;
0966                                              return returnValue;
0967                                            });
0968         registerProcessBlockCacheFiller<TestInputProcessBlockCache1>(
0969             getTokenBegin_,
0970             [this](edm::ProcessBlock const& processBlock,
0971                    std::shared_ptr<TestInputProcessBlockCache1> const& previousCache) {
0972               auto returnValue = std::make_shared<TestInputProcessBlockCache1>();
0973               returnValue->value_ += processBlock.get(getTokenBegin_).value;
0974               returnValue->value_ += processBlock.get(getTokenEnd_).value;
0975               ++transitions_;
0976               return returnValue;
0977             });
0978       }
0979 
0980       void accessInputProcessBlock(edm::ProcessBlock const& processBlock) override {
0981         if (processBlock.processName() == "PROD1") {
0982           sum_ += processBlock.get(getTokenBegin_).value;
0983           sum_ += processBlock.get(getTokenEnd_).value;
0984         }
0985         if (processBlock.processName() == "MERGE") {
0986           sum_ += processBlock.get(getTokenBeginM_).value;
0987           sum_ += processBlock.get(getTokenEndM_).value;
0988         }
0989         ++transitions_;
0990       }
0991 
0992       void produce(edm::StreamID, edm::Event& event, edm::EventSetup const&) const override {
0993         auto cacheTuple = processBlockCaches(event);
0994         if (!expectedByRun_.empty()) {
0995           if (expectedByRun_.at(event.run() - 1) != *std::get<edm::CacheHandle<int>>(cacheTuple)) {
0996             throw cms::Exception("UnexpectedValue")
0997                 << "InputProcessBlockIntProducer::produce cached value was "
0998                 << *std::get<edm::CacheHandle<int>>(cacheTuple) << " but it was supposed to be "
0999                 << expectedByRun_.at(event.run() - 1);
1000           }
1001           if (expectedByRun_.at(event.run() - 1) != std::get<1>(cacheTuple)->value_) {
1002             throw cms::Exception("UnexpectedValue")
1003                 << "InputProcessBlockIntProducer::produce second cached value was " << std::get<1>(cacheTuple)->value_
1004                 << " but it was supposed to be " << expectedByRun_.at(event.run() - 1);
1005           }
1006           if (expectedByRun_.at(event.run() - 1) !=
1007               std::get<edm::CacheHandle<TestInputProcessBlockCache1>>(cacheTuple)->value_) {
1008             throw cms::Exception("UnexpectedValue")
1009                 << "InputProcessBlockIntProducer::produce third cached value was "
1010                 << std::get<edm::CacheHandle<TestInputProcessBlockCache1>>(cacheTuple)->value_
1011                 << " but it was supposed to be " << expectedByRun_.at(event.run() - 1);
1012           }
1013         }
1014         ++transitions_;
1015       }
1016 
1017       void endJob() override {
1018         if (transitions_ != expectedTransitions_) {
1019           throw cms::Exception("transitions") << "InputProcessBlockIntProducer transitions " << transitions_
1020                                               << " but it was supposed to be " << expectedTransitions_;
1021         }
1022         if (sum_ != expectedSum_) {
1023           throw cms::Exception("UnexpectedValue")
1024               << "InputProcessBlockIntProducer sum " << sum_ << " but it was supposed to be " << expectedSum_;
1025         }
1026         if (cacheSize() > 0u) {
1027           throw cms::Exception("UnexpectedValue")
1028               << "InputProcessBlockIntProducer cache size not zero at endJob " << cacheSize();
1029         }
1030       }
1031 
1032     private:
1033       edm::EDGetTokenT<IntProduct> getTokenBegin_;
1034       edm::EDGetTokenT<IntProduct> getTokenEnd_;
1035       edm::EDGetTokenT<IntProduct> getTokenBeginM_;
1036       edm::EDGetTokenT<IntProduct> getTokenEndM_;
1037       mutable std::atomic<unsigned int> transitions_{0};
1038       int sum_{0};
1039       unsigned int expectedTransitions_{0};
1040       std::vector<int> expectedByRun_;
1041       int expectedSum_{0};
1042     };
1043 
1044   }  // namespace limited
1045 }  // namespace edmtest
1046 
1047 DEFINE_FWK_MODULE(edmtest::limited::StreamIntProducer);
1048 DEFINE_FWK_MODULE(edmtest::limited::RunIntProducer);
1049 DEFINE_FWK_MODULE(edmtest::limited::LumiIntProducer);
1050 DEFINE_FWK_MODULE(edmtest::limited::RunSummaryIntProducer);
1051 DEFINE_FWK_MODULE(edmtest::limited::LumiSummaryIntProducer);
1052 DEFINE_FWK_MODULE(edmtest::limited::LumiSummaryLumiProducer);
1053 DEFINE_FWK_MODULE(edmtest::limited::ProcessBlockIntProducer);
1054 DEFINE_FWK_MODULE(edmtest::limited::TestBeginProcessBlockProducer);
1055 DEFINE_FWK_MODULE(edmtest::limited::TestEndProcessBlockProducer);
1056 DEFINE_FWK_MODULE(edmtest::limited::TestBeginRunProducer);
1057 DEFINE_FWK_MODULE(edmtest::limited::TestEndRunProducer);
1058 DEFINE_FWK_MODULE(edmtest::limited::TestBeginLumiBlockProducer);
1059 DEFINE_FWK_MODULE(edmtest::limited::TestEndLumiBlockProducer);
1060 DEFINE_FWK_MODULE(edmtest::limited::TestAccumulator);
1061 DEFINE_FWK_MODULE(edmtest::limited::InputProcessBlockIntProducer);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!