Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-07-19 01:43:55

0001 
0002 /*----------------------------------------------------------------------
0003 
0004 Toy edm::limited::EDAnalyzer modules of
0005 edm::*Cache templates
0006 for testing purposes only.
0007 
0008 ----------------------------------------------------------------------*/
0009 
0010 #include <atomic>
0011 #include <iostream>
0012 #include <memory>
0013 #include <tuple>
0014 #include <vector>
0015 
0016 #include "DataFormats/Provenance/interface/BranchDescription.h"
0017 #include "DataFormats/TestObjects/interface/ToyProducts.h"
0018 #include "FWCore/Framework/interface/CacheHandle.h"
0019 #include "FWCore/Framework/interface/Event.h"
0020 #include "FWCore/Framework/interface/LuminosityBlock.h"
0021 #include "FWCore/Framework/interface/MakerMacros.h"
0022 #include "FWCore/Framework/interface/moduleAbilities.h"
0023 #include "FWCore/Framework/interface/limited/EDAnalyzer.h"
0024 #include "FWCore/Framework/interface/ProcessBlock.h"
0025 #include "FWCore/Framework/interface/Run.h"
0026 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0027 #include "FWCore/Utilities/interface/BranchType.h"
0028 #include "FWCore/Utilities/interface/EDMException.h"
0029 #include "FWCore/Utilities/interface/EDGetToken.h"
0030 #include "FWCore/Utilities/interface/InputTag.h"
0031 
0032 namespace edmtest {
0033   namespace limited {
0034 
0035     namespace {
0036       struct Cache {
0037         Cache() : value(0) {}
0038         //Using mutable since we want to update the value.
0039         mutable std::atomic<unsigned int> value;
0040       };
0041 
0042       struct UnsafeCache {
0043         UnsafeCache() : value(0), lumi(0) {}
0044         unsigned int value;
0045         unsigned int lumi;
0046       };
0047 
0048     }  //end anonymous namespace
0049 
0050     class StreamIntAnalyzer : public edm::limited::EDAnalyzer<edm::StreamCache<UnsafeCache>> {
0051     public:
0052       explicit StreamIntAnalyzer(edm::ParameterSet const& p)
0053           : edm::limited::EDAnalyzerBase(p),
0054             edm::limited::EDAnalyzer<edm::StreamCache<UnsafeCache>>(p),
0055             trans_(p.getParameter<int>("transitions")) {
0056         callWhenNewProductsRegistered([](edm::BranchDescription const& desc) {
0057           std::cout << "limited::StreamIntAnalyzer " << desc.moduleLabel() << std::endl;
0058         });
0059       }
0060       const unsigned int trans_;
0061       mutable std::atomic<unsigned int> m_count{0};
0062 
0063       std::unique_ptr<UnsafeCache> beginStream(edm::StreamID iID) const override {
0064         ++m_count;
0065         auto pCache = std::make_unique<UnsafeCache>();
0066         pCache->value = iID.value();
0067         return pCache;
0068       }
0069 
0070       void streamBeginRun(edm::StreamID iID, edm::Run const&, edm::EventSetup const&) const override {
0071         ++m_count;
0072         if ((streamCache(iID))->value != iID.value()) {
0073           throw cms::Exception("cache value")
0074               << "StreamIntAnalyzer cache value " << (streamCache(iID))->value << " but it was supposed to be " << iID;
0075         }
0076       }
0077 
0078       void streamBeginLuminosityBlock(edm::StreamID iID,
0079                                       edm::LuminosityBlock const&,
0080                                       edm::EventSetup const&) const override {
0081         ++m_count;
0082         if ((streamCache(iID))->value != iID.value()) {
0083           throw cms::Exception("cache value")
0084               << "StreamIntAnalyzer cache value " << (streamCache(iID))->value << " but it was supposed to be " << iID;
0085         }
0086       }
0087 
0088       void analyze(edm::StreamID iID, const edm::Event&, const edm::EventSetup&) const override {
0089         ++m_count;
0090         if ((streamCache(iID))->value != iID.value()) {
0091           throw cms::Exception("cache value")
0092               << "StreamIntAnalyzer cache value " << (streamCache(iID))->value << " but it was supposed to be " << iID;
0093         }
0094       }
0095 
0096       void streamEndLuminosityBlock(edm::StreamID iID,
0097                                     edm::LuminosityBlock const&,
0098                                     edm::EventSetup const&) const override {
0099         ++m_count;
0100         if ((streamCache(iID))->value != iID.value()) {
0101           throw cms::Exception("cache value")
0102               << "StreamIntAnalyzer cache value " << (streamCache(iID))->value << " but it was supposed to be " << iID;
0103         }
0104       }
0105 
0106       void streamEndRun(edm::StreamID iID, edm::Run const&, edm::EventSetup const&) const override {
0107         ++m_count;
0108         if ((streamCache(iID))->value != iID.value()) {
0109           throw cms::Exception("cache value")
0110               << "StreamIntAnalyzer cache value " << (streamCache(iID))->value << " but it was supposed to be " << iID;
0111         }
0112       }
0113 
0114       void endStream(edm::StreamID iID) const override {
0115         ++m_count;
0116         if ((streamCache(iID))->value != iID.value()) {
0117           throw cms::Exception("cache value")
0118               << "StreamIntAnalyzer cache value " << (streamCache(iID))->value << " but it was supposed to be " << iID;
0119         }
0120       }
0121 
0122       ~StreamIntAnalyzer() {
0123         if (m_count != trans_) {
0124           throw cms::Exception("transitions")
0125               << "StreamIntAnalyzer transitions " << m_count << " but it was supposed to be " << trans_;
0126         }
0127       }
0128     };
0129 
0130     class RunIntAnalyzer : public edm::limited::EDAnalyzer<edm::RunCache<Cache>> {
0131     public:
0132       explicit RunIntAnalyzer(edm::ParameterSet const& p)
0133           : edm::limited::EDAnalyzerBase(p),
0134             edm::limited::EDAnalyzer<edm::RunCache<Cache>>(p),
0135             trans_(p.getParameter<int>("transitions")),
0136             cvalue_(p.getParameter<int>("cachevalue")) {}
0137       const unsigned int trans_;
0138       const unsigned int cvalue_;
0139       mutable std::atomic<unsigned int> m_count{0};
0140 
0141       std::shared_ptr<Cache> globalBeginRun(edm::Run const&, edm::EventSetup const&) const override {
0142         ++m_count;
0143         return std::make_shared<Cache>();
0144       }
0145 
0146       void analyze(edm::StreamID iID, const edm::Event& iEvent, const edm::EventSetup&) const override {
0147         ++m_count;
0148         ++((runCache(iEvent.getRun().index()))->value);
0149       }
0150 
0151       void globalEndRun(edm::Run const& iRun, edm::EventSetup const&) const override {
0152         ++m_count;
0153         if ((runCache(iRun.index()))->value != cvalue_) {
0154           throw cms::Exception("cache value") << "RunIntAnalyzer cache value " << (runCache(iRun.index()))->value
0155                                               << " but it was supposed to be " << cvalue_;
0156         }
0157       }
0158 
0159       ~RunIntAnalyzer() {
0160         if (m_count != trans_) {
0161           throw cms::Exception("transitions")
0162               << "RunIntAnalyzer transitions " << m_count << " but it was supposed to be " << trans_;
0163         }
0164       }
0165     };
0166 
0167     class LumiIntAnalyzer : public edm::limited::EDAnalyzer<edm::LuminosityBlockCache<Cache>> {
0168     public:
0169       explicit LumiIntAnalyzer(edm::ParameterSet const& p)
0170           : edm::limited::EDAnalyzerBase(p),
0171             edm::limited::EDAnalyzer<edm::LuminosityBlockCache<Cache>>(p),
0172             trans_(p.getParameter<int>("transitions")),
0173             cvalue_(p.getParameter<int>("cachevalue")) {
0174         // just to create a data dependence
0175         auto const& tag = p.getParameter<edm::InputTag>("moduleLabel");
0176         if (not tag.label().empty()) {
0177           consumes<unsigned int, edm::InLumi>(tag);
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> globalBeginLuminosityBlock(edm::LuminosityBlock const&,
0185                                                         edm::EventSetup const&) const override {
0186         ++m_count;
0187         return std::make_shared<Cache>();
0188       }
0189 
0190       void analyze(edm::StreamID, const edm::Event& iEvent, const edm::EventSetup&) const override {
0191         ++m_count;
0192         ++(luminosityBlockCache(iEvent.getLuminosityBlock().index())->value);
0193       }
0194 
0195       void globalEndLuminosityBlock(edm::LuminosityBlock const& iLB, edm::EventSetup const&) const override {
0196         ++m_count;
0197         if ((luminosityBlockCache(iLB.index()))->value != cvalue_) {
0198           throw cms::Exception("cache value")
0199               << "LumiIntAnalyzer cache value " << (luminosityBlockCache(iLB.index()))->value
0200               << " but it was supposed to be " << cvalue_;
0201         }
0202       }
0203 
0204       ~LumiIntAnalyzer() {
0205         if (m_count != trans_) {
0206           throw cms::Exception("transitions")
0207               << "LumiIntAnalyzer transitions " << m_count << " but it was supposed to be " << trans_;
0208         }
0209       }
0210     };
0211 
0212     class RunSummaryIntAnalyzer
0213         : public edm::limited::EDAnalyzer<edm::StreamCache<UnsafeCache>, edm::RunSummaryCache<UnsafeCache>> {
0214     public:
0215       explicit RunSummaryIntAnalyzer(edm::ParameterSet const& p)
0216           : edm::limited::EDAnalyzerBase(p),
0217             edm::limited::EDAnalyzer<edm::StreamCache<UnsafeCache>, edm::RunSummaryCache<UnsafeCache>>(p),
0218             trans_(p.getParameter<int>("transitions")),
0219             cvalue_(p.getParameter<int>("cachevalue")) {}
0220       const unsigned int trans_;
0221       const unsigned int cvalue_;
0222       mutable std::atomic<unsigned int> m_count{0};
0223 
0224       std::unique_ptr<UnsafeCache> beginStream(edm::StreamID) const override {
0225         ++m_count;
0226         return std::make_unique<UnsafeCache>();
0227       }
0228 
0229       std::shared_ptr<UnsafeCache> globalBeginRunSummary(edm::Run const&, edm::EventSetup const&) const override {
0230         ++m_count;
0231         return std::make_shared<UnsafeCache>();
0232       }
0233 
0234       void analyze(edm::StreamID iID, const edm::Event&, const edm::EventSetup&) const override {
0235         ++m_count;
0236         ++((streamCache(iID))->value);
0237       }
0238 
0239       void streamEndRunSummary(edm::StreamID iID,
0240                                edm::Run const&,
0241                                edm::EventSetup const&,
0242                                UnsafeCache* gCache) const override {
0243         ++m_count;
0244         gCache->value += (streamCache(iID))->value;
0245         (streamCache(iID))->value = 0;
0246       }
0247 
0248       void globalEndRunSummary(edm::Run const&, edm::EventSetup const&, UnsafeCache* gCache) const override {
0249         ++m_count;
0250         if (gCache->value != cvalue_) {
0251           throw cms::Exception("cache value")
0252               << "RunSummaryIntAnalyzer cache value " << gCache->value << " but it was supposed to be " << cvalue_;
0253         }
0254       }
0255 
0256       ~RunSummaryIntAnalyzer() {
0257         if (m_count != trans_) {
0258           throw cms::Exception("transitions")
0259               << "RunSummaryIntAnalyzer transitions " << m_count << " but it was supposed to be " << trans_;
0260         }
0261       }
0262     };
0263 
0264     class LumiSummaryIntAnalyzer
0265         : public edm::limited::EDAnalyzer<edm::StreamCache<UnsafeCache>, edm::LuminosityBlockSummaryCache<UnsafeCache>> {
0266     public:
0267       explicit LumiSummaryIntAnalyzer(edm::ParameterSet const& p)
0268           : edm::limited::EDAnalyzerBase(p),
0269             edm::limited::EDAnalyzer<edm::StreamCache<UnsafeCache>, edm::LuminosityBlockSummaryCache<UnsafeCache>>(p),
0270             trans_(p.getParameter<int>("transitions")),
0271             cvalue_(p.getParameter<int>("cachevalue")) {}
0272       const unsigned int trans_;
0273       const unsigned int cvalue_;
0274       mutable std::atomic<unsigned int> m_count{0};
0275 
0276       std::unique_ptr<UnsafeCache> beginStream(edm::StreamID) const override {
0277         ++m_count;
0278         return std::make_unique<UnsafeCache>();
0279       }
0280 
0281       std::shared_ptr<UnsafeCache> globalBeginLuminosityBlockSummary(edm::LuminosityBlock const& iLB,
0282                                                                      edm::EventSetup const&) const override {
0283         ++m_count;
0284         auto gCache = std::make_shared<UnsafeCache>();
0285         gCache->lumi = iLB.luminosityBlockAuxiliary().luminosityBlock();
0286         return gCache;
0287       }
0288 
0289       void analyze(edm::StreamID iID, const edm::Event& iEvent, const edm::EventSetup&) const override {
0290         ++m_count;
0291         ++((streamCache(iID))->value);
0292       }
0293 
0294       void streamEndLuminosityBlockSummary(edm::StreamID iID,
0295                                            edm::LuminosityBlock const& iLB,
0296                                            edm::EventSetup const&,
0297                                            UnsafeCache* gCache) const override {
0298         ++m_count;
0299         if (gCache->lumi != iLB.luminosityBlockAuxiliary().luminosityBlock()) {
0300           throw cms::Exception("UnexpectedValue")
0301               << "streamEndLuminosityBlockSummary unexpected lumi number in Stream " << iID.value();
0302         }
0303         gCache->value += (streamCache(iID))->value;
0304         (streamCache(iID))->value = 0;
0305       }
0306 
0307       void globalEndLuminosityBlockSummary(edm::LuminosityBlock const& iLB,
0308                                            edm::EventSetup const&,
0309                                            UnsafeCache* gCache) const override {
0310         ++m_count;
0311         if (gCache->lumi != iLB.luminosityBlockAuxiliary().luminosityBlock()) {
0312           throw cms::Exception("UnexpectedValue") << "globalEndLuminosityBlockSummary unexpected lumi number";
0313         }
0314         if (gCache->value != cvalue_) {
0315           throw cms::Exception("cache value")
0316               << "LumiSummaryIntAnalyzer cache value " << gCache->value << " but it was supposed to be " << cvalue_;
0317         }
0318       }
0319 
0320       ~LumiSummaryIntAnalyzer() {
0321         if (m_count != trans_) {
0322           throw cms::Exception("transitions")
0323               << "LumiSummaryIntAnalyzer transitions " << m_count << " but it was supposed to be " << trans_;
0324         }
0325       }
0326     };
0327 
0328     class ProcessBlockIntAnalyzer : public edm::limited::EDAnalyzer<edm::WatchProcessBlock> {
0329     public:
0330       explicit ProcessBlockIntAnalyzer(edm::ParameterSet const& pset)
0331           : edm::limited::EDAnalyzerBase(pset),
0332             edm::limited::EDAnalyzer<edm::WatchProcessBlock>(pset),
0333             trans_(pset.getParameter<int>("transitions")) {
0334         {
0335           auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlock");
0336           if (not tag.label().empty()) {
0337             getTokenBegin_ = consumes<unsigned int, edm::InProcess>(tag);
0338           }
0339         }
0340         {
0341           auto tag = pset.getParameter<edm::InputTag>("consumesEndProcessBlock");
0342           if (not tag.label().empty()) {
0343             getTokenEnd_ = consumes<unsigned int, edm::InProcess>(tag);
0344           }
0345         }
0346       }
0347 
0348       void beginProcessBlock(edm::ProcessBlock const& processBlock) override {
0349         if (m_count != 0) {
0350           throw cms::Exception("transitions")
0351               << "ProcessBlockIntAnalyzer::begin transitions " << m_count << " but it was supposed to be " << 0;
0352         }
0353         ++m_count;
0354         const unsigned int valueToGet = 11;
0355         if (not getTokenBegin_.isUninitialized()) {
0356           if (processBlock.get(getTokenBegin_) != valueToGet) {
0357             throw cms::Exception("BadValue")
0358                 << "expected " << valueToGet << " but got " << processBlock.get(getTokenBegin_);
0359           }
0360         }
0361       }
0362 
0363       void analyze(edm::StreamID iID, edm::Event const&, edm::EventSetup const&) const override {
0364         if (m_count < 1u) {
0365           throw cms::Exception("out of sequence") << "analyze before beginProcessBlock " << m_count;
0366         }
0367         ++m_count;
0368       }
0369 
0370       void endProcessBlock(edm::ProcessBlock const& processBlock) override {
0371         ++m_count;
0372         if (m_count != trans_) {
0373           throw cms::Exception("transitions")
0374               << "ProcessBlockIntAnalyzer::end transitions " << m_count << " but it was supposed to be " << trans_;
0375         }
0376         {
0377           const unsigned int valueToGet = 11;
0378           if (not getTokenBegin_.isUninitialized()) {
0379             if (processBlock.get(getTokenBegin_) != valueToGet) {
0380               throw cms::Exception("BadValue")
0381                   << "expected " << valueToGet << " but got " << processBlock.get(getTokenBegin_);
0382             }
0383           }
0384         }
0385         {
0386           const unsigned int valueToGet = 21;
0387           if (not getTokenEnd_.isUninitialized()) {
0388             if (processBlock.get(getTokenEnd_) != valueToGet) {
0389               throw cms::Exception("BadValue")
0390                   << "expected " << valueToGet << " but got " << processBlock.get(getTokenEnd_);
0391             }
0392           }
0393         }
0394       }
0395 
0396       ~ProcessBlockIntAnalyzer() {
0397         if (m_count != trans_) {
0398           throw cms::Exception("transitions")
0399               << "ProcessBlockIntAnalyzer transitions " << m_count << " but it was supposed to be " << trans_;
0400         }
0401       }
0402 
0403     private:
0404       const unsigned int trans_;
0405       mutable std::atomic<unsigned int> m_count{0};
0406       edm::EDGetTokenT<unsigned int> getTokenBegin_;
0407       edm::EDGetTokenT<unsigned int> getTokenEnd_;
0408     };
0409 
0410     class TestInputProcessBlockCache {
0411     public:
0412       long long int value_ = 0;
0413     };
0414 
0415     class TestInputProcessBlockCache1 {
0416     public:
0417       long long int value_ = 0;
0418     };
0419 
0420     class InputProcessBlockIntAnalyzer
0421         : public edm::limited::EDAnalyzer<
0422               edm::InputProcessBlockCache<int, TestInputProcessBlockCache, TestInputProcessBlockCache1>> {
0423     public:
0424       explicit InputProcessBlockIntAnalyzer(edm::ParameterSet const& pset)
0425           : edm::limited::EDAnalyzerBase(pset),
0426             edm::limited::EDAnalyzer<
0427                 edm::InputProcessBlockCache<int, TestInputProcessBlockCache, TestInputProcessBlockCache1>>(pset) {
0428         expectedTransitions_ = pset.getParameter<int>("transitions");
0429         expectedByRun_ = pset.getParameter<std::vector<int>>("expectedByRun");
0430         expectedSum_ = pset.getParameter<int>("expectedSum");
0431         {
0432           auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlock");
0433           if (not tag.label().empty()) {
0434             getTokenBegin_ = consumes<IntProduct, edm::InProcess>(tag);
0435           }
0436         }
0437         {
0438           auto tag = pset.getParameter<edm::InputTag>("consumesEndProcessBlock");
0439           if (not tag.label().empty()) {
0440             getTokenEnd_ = consumes<IntProduct, edm::InProcess>(tag);
0441           }
0442         }
0443         {
0444           auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlockM");
0445           if (not tag.label().empty()) {
0446             getTokenBeginM_ = consumes<IntProduct, edm::InProcess>(tag);
0447           }
0448         }
0449         {
0450           auto tag = pset.getParameter<edm::InputTag>("consumesEndProcessBlockM");
0451           if (not tag.label().empty()) {
0452             getTokenEndM_ = consumes<IntProduct, edm::InProcess>(tag);
0453           }
0454         }
0455         registerProcessBlockCacheFiller<int>(
0456             getTokenBegin_, [this](edm::ProcessBlock const& processBlock, std::shared_ptr<int> const& previousCache) {
0457               auto returnValue = std::make_shared<int>(0);
0458               *returnValue += processBlock.get(getTokenBegin_).value;
0459               *returnValue += processBlock.get(getTokenEnd_).value;
0460               ++transitions_;
0461               return returnValue;
0462             });
0463         registerProcessBlockCacheFiller<1>(getTokenBegin_,
0464                                            [this](edm::ProcessBlock const& processBlock,
0465                                                   std::shared_ptr<TestInputProcessBlockCache> const& previousCache) {
0466                                              auto returnValue = std::make_shared<TestInputProcessBlockCache>();
0467                                              returnValue->value_ += processBlock.get(getTokenBegin_).value;
0468                                              returnValue->value_ += processBlock.get(getTokenEnd_).value;
0469                                              ++transitions_;
0470                                              return returnValue;
0471                                            });
0472         registerProcessBlockCacheFiller<TestInputProcessBlockCache1>(
0473             getTokenBegin_,
0474             [this](edm::ProcessBlock const& processBlock,
0475                    std::shared_ptr<TestInputProcessBlockCache1> const& previousCache) {
0476               auto returnValue = std::make_shared<TestInputProcessBlockCache1>();
0477               returnValue->value_ += processBlock.get(getTokenBegin_).value;
0478               returnValue->value_ += processBlock.get(getTokenEnd_).value;
0479               ++transitions_;
0480               return returnValue;
0481             });
0482       }
0483 
0484       void accessInputProcessBlock(edm::ProcessBlock const& processBlock) override {
0485         if (processBlock.processName() == "PROD1") {
0486           sum_ += processBlock.get(getTokenBegin_).value;
0487           sum_ += processBlock.get(getTokenEnd_).value;
0488         }
0489         if (processBlock.processName() == "MERGE") {
0490           sum_ += processBlock.get(getTokenBeginM_).value;
0491           sum_ += processBlock.get(getTokenEndM_).value;
0492         }
0493         ++transitions_;
0494       }
0495 
0496       void analyze(edm::StreamID, edm::Event const& event, edm::EventSetup const&) const override {
0497         auto cacheTuple = processBlockCaches(event);
0498         if (!expectedByRun_.empty()) {
0499           if (expectedByRun_.at(event.run() - 1) != *std::get<edm::CacheHandle<int>>(cacheTuple)) {
0500             throw cms::Exception("UnexpectedValue")
0501                 << "InputProcessBlockIntAnalyzer::analyze cached value was "
0502                 << *std::get<edm::CacheHandle<int>>(cacheTuple) << " but it was supposed to be "
0503                 << expectedByRun_.at(event.run() - 1);
0504           }
0505           if (expectedByRun_.at(event.run() - 1) != std::get<1>(cacheTuple)->value_) {
0506             throw cms::Exception("UnexpectedValue")
0507                 << "InputProcessBlockIntAnalyzer::analyze second cached value was " << std::get<1>(cacheTuple)->value_
0508                 << " but it was supposed to be " << expectedByRun_.at(event.run() - 1);
0509           }
0510           if (expectedByRun_.at(event.run() - 1) !=
0511               std::get<edm::CacheHandle<TestInputProcessBlockCache1>>(cacheTuple)->value_) {
0512             throw cms::Exception("UnexpectedValue")
0513                 << "InputProcessBlockIntAnalyzer::analyze third cached value was "
0514                 << std::get<edm::CacheHandle<TestInputProcessBlockCache1>>(cacheTuple)->value_
0515                 << " but it was supposed to be " << expectedByRun_.at(event.run() - 1);
0516           }
0517         }
0518         ++transitions_;
0519       }
0520 
0521       void endJob() override {
0522         if (transitions_ != expectedTransitions_) {
0523           throw cms::Exception("transitions") << "InputProcessBlockIntAnalyzer transitions " << transitions_
0524                                               << " but it was supposed to be " << expectedTransitions_;
0525         }
0526         if (sum_ != expectedSum_) {
0527           throw cms::Exception("UnexpectedValue")
0528               << "InputProcessBlockIntAnalyzer sum " << sum_ << " but it was supposed to be " << expectedSum_;
0529         }
0530         if (cacheSize() > 0u) {
0531           throw cms::Exception("UnexpectedValue")
0532               << "InputProcessBlockIntAnalyzer cache size not zero at endJob " << cacheSize();
0533         }
0534       }
0535 
0536     private:
0537       edm::EDGetTokenT<IntProduct> getTokenBegin_;
0538       edm::EDGetTokenT<IntProduct> getTokenEnd_;
0539       edm::EDGetTokenT<IntProduct> getTokenBeginM_;
0540       edm::EDGetTokenT<IntProduct> getTokenEndM_;
0541       mutable std::atomic<unsigned int> transitions_{0};
0542       int sum_{0};
0543       unsigned int expectedTransitions_{0};
0544       std::vector<int> expectedByRun_;
0545       int expectedSum_{0};
0546     };
0547 
0548   }  // namespace limited
0549 }  // namespace edmtest
0550 
0551 DEFINE_FWK_MODULE(edmtest::limited::StreamIntAnalyzer);
0552 DEFINE_FWK_MODULE(edmtest::limited::RunIntAnalyzer);
0553 DEFINE_FWK_MODULE(edmtest::limited::LumiIntAnalyzer);
0554 DEFINE_FWK_MODULE(edmtest::limited::RunSummaryIntAnalyzer);
0555 DEFINE_FWK_MODULE(edmtest::limited::LumiSummaryIntAnalyzer);
0556 DEFINE_FWK_MODULE(edmtest::limited::ProcessBlockIntAnalyzer);
0557 DEFINE_FWK_MODULE(edmtest::limited::InputProcessBlockIntAnalyzer);