Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-01-14 02:38:43 

0001 /*
0002  *  proxyfactoryproducer_t.cc
0003  *  EDMProto
0004  *
0005  *  Created by Chris Jones on 4/8/05.
0006  *  Changed by Viji Sundararajan on 28-Jun-05
0007  */
0008 #include <iostream>
0009 #include <atomic>
0010 #include <vector>
0011 #include <map>
0012 #include <functional>
0013 #include "oneapi/tbb/global_control.h"
0014 #include "FWCore/Framework/interface/limited/EDFilter.h"
0015 #include "FWCore/Framework/interface/maker/WorkerT.h"
0016 #include "FWCore/Framework/interface/maker/ModuleHolder.h"
0017 #include "FWCore/Framework/interface/PreallocationConfiguration.h"
0018 #include "FWCore/Framework/interface/TransitionInfoTypes.h"
0019 #include "FWCore/Framework/interface/OccurrenceTraits.h"
0020 #include "FWCore/Framework/interface/ProductResolversFactory.h"
0021 #include "DataFormats/Provenance/interface/ProductRegistry.h"
0022 #include "DataFormats/Provenance/interface/BranchIDListHelper.h"
0023 #include "DataFormats/Provenance/interface/ThinnedAssociationsHelper.h"
0024 #include "FWCore/Framework/interface/HistoryAppender.h"
0025 #include "FWCore/ServiceRegistry/interface/ParentContext.h"
0026 #include "FWCore/ServiceRegistry/interface/StreamContext.h"
0027 #include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
0028 #include "FWCore/Concurrency/interface/FinalWaitingTask.h"
0029 #include "FWCore/Utilities/interface/GlobalIdentifier.h"
0030 
0031 #include "FWCore/Utilities/interface/Exception.h"
0032 
0033 #include "cppunit/extensions/HelperMacros.h"
0034 
0035 namespace {
0036   edm::ParameterSet makePSet() {
0037     edm::ParameterSet pset;
0038     const unsigned int kLimit = 1;
0039     pset.addUntrackedParameter("concurrencyLimit", kLimit);
0040     return pset;
0041   }
0042 
0043   const edm::ParameterSet s_pset = makePSet();
0044 }  // namespace
0045 
0046 namespace {
0047   struct ShadowStreamID {
0048     constexpr ShadowStreamID() : value(0) {}
0049     unsigned int value;
0050   };
0051 
0052   union IDUnion {
0053     IDUnion() : m_shadow() {}
0054     ShadowStreamID m_shadow;
0055     edm::StreamID m_id;
0056   };
0057 }  // namespace
0058 static edm::StreamID makeID() {
0059   IDUnion u;
0060   assert(u.m_id.value() == 0);
0061   return u.m_id;
0062 }
0063 static const edm::StreamID s_streamID0 = makeID();
0064 
0065 class testLimitedFilter : public CppUnit::TestFixture {
0066   CPPUNIT_TEST_SUITE(testLimitedFilter);
0067 
0068   CPPUNIT_TEST(basicTest);
0069   CPPUNIT_TEST(streamTest);
0070   CPPUNIT_TEST(runTest);
0071   CPPUNIT_TEST(runSummaryTest);
0072   CPPUNIT_TEST(lumiTest);
0073   CPPUNIT_TEST(lumiSummaryTest);
0074   CPPUNIT_TEST(beginRunProdTest);
0075   CPPUNIT_TEST(beginLumiProdTest);
0076   CPPUNIT_TEST(endRunProdTest);
0077   CPPUNIT_TEST(endLumiProdTest);
0078   CPPUNIT_TEST(endRunSummaryProdTest);
0079   CPPUNIT_TEST(endLumiSummaryProdTest);
0080 
0081   CPPUNIT_TEST_SUITE_END();
0082 
0083 public:
0084   testLimitedFilter();
0085 
0086   void setUp() {}
0087   void tearDown() {}
0088 
0089   void basicTest();
0090   void streamTest();
0091   void runTest();
0092   void runSummaryTest();
0093   void lumiTest();
0094   void lumiSummaryTest();
0095   void beginRunProdTest();
0096   void beginLumiProdTest();
0097   void endRunProdTest();
0098   void endLumiProdTest();
0099   void endRunSummaryProdTest();
0100   void endLumiSummaryProdTest();
0101 
0102   enum class Trans {
0103     kBeginJob,
0104     kBeginStream,
0105     kGlobalBeginRun,
0106     kGlobalBeginRunProduce,
0107     kStreamBeginRun,
0108     kGlobalBeginLuminosityBlock,
0109     kStreamBeginLuminosityBlock,
0110     kEvent,
0111     kStreamEndLuminosityBlock,
0112     kGlobalEndLuminosityBlock,
0113     kStreamEndRun,
0114     kGlobalEndRun,
0115     kEndStream,
0116     kEndJob
0117   };
0118   typedef std::vector<Trans> Expectations;
0119 
0120 private:
0121   std::map<Trans, std::function<void(edm::Worker*)>> m_transToFunc;
0122 
0123   edm::ProcessConfiguration m_procConfig;
0124   std::shared_ptr<edm::ProductRegistry> m_prodReg;
0125   std::shared_ptr<edm::BranchIDListHelper> m_idHelper;
0126   std::shared_ptr<edm::ThinnedAssociationsHelper> m_associationsHelper;
0127   std::unique_ptr<edm::EventPrincipal> m_ep;
0128   edm::HistoryAppender historyAppender_;
0129   std::shared_ptr<edm::LuminosityBlockPrincipal> m_lbp;
0130   std::shared_ptr<edm::RunPrincipal> m_rp;
0131   std::shared_ptr<edm::ActivityRegistry>
0132       m_actReg;  // We do not use propagate_const because the registry itself is mutable.
0133   edm::EventSetupImpl* m_es = nullptr;
0134   edm::ModuleDescription m_desc = {"Dummy", "dummy"};
0135 
0136   template <typename T>
0137   void testTransitions(std::shared_ptr<T> iMod, Expectations const& iExpect);
0138 
0139   template <typename Traits, typename Info>
0140   void doWork(edm::Worker* iBase, Info const& info, edm::ParentContext const& iContext) {
0141     oneapi::tbb::task_group group;
0142     edm::FinalWaitingTask task{group};
0143     edm::ServiceToken token;
0144     iBase->doWorkAsync<Traits>(edm::WaitingTaskHolder(group, &task), info, token, s_streamID0, iContext, nullptr);
0145     task.wait();
0146   }
0147 
0148   class BasicProd : public edm::limited::EDFilter<> {
0149   public:
0150     BasicProd() : edm::limited::EDFilterBase(s_pset), edm::limited::EDFilter<>(s_pset) {}
0151     mutable unsigned int m_count = 0;  //[[cms-thread-safe]]
0152 
0153     bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {
0154       ++m_count;
0155       return true;
0156     }
0157   };
0158   class StreamProd : public edm::limited::EDFilter<edm::StreamCache<int>> {
0159   public:
0160     StreamProd() : edm::limited::EDFilterBase(s_pset), edm::limited::EDFilter<edm::StreamCache<int>>(s_pset) {}
0161     mutable unsigned int m_count = 0;
0162     bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {
0163       ++m_count;
0164       return true;
0165     }
0166 
0167     std::unique_ptr<int> beginStream(edm::StreamID) const override {
0168       ++m_count;
0169       return std::unique_ptr<int>{};
0170     }
0171 
0172     virtual void streamBeginRun(edm::StreamID, edm::Run const&, edm::EventSetup const&) const override { ++m_count; }
0173     virtual void streamBeginLuminosityBlock(edm::StreamID,
0174                                             edm::LuminosityBlock const&,
0175                                             edm::EventSetup const&) const override {
0176       ++m_count;
0177     }
0178     virtual void streamEndLuminosityBlock(edm::StreamID,
0179                                           edm::LuminosityBlock const&,
0180                                           edm::EventSetup const&) const override {
0181       ++m_count;
0182     }
0183     virtual void streamEndRun(edm::StreamID, edm::Run const&, edm::EventSetup const&) const override { ++m_count; }
0184     void endStream(edm::StreamID) const override { ++m_count; }
0185   };
0186 
0187   class RunProd : public edm::limited::EDFilter<edm::RunCache<int>> {
0188   public:
0189     RunProd() : edm::limited::EDFilterBase(s_pset), edm::limited::EDFilter<edm::RunCache<int>>(s_pset) {}
0190     mutable unsigned int m_count = 0;
0191     bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {
0192       ++m_count;
0193       return true;
0194     }
0195 
0196     std::shared_ptr<int> globalBeginRun(edm::Run const&, edm::EventSetup const&) const override {
0197       ++m_count;
0198       return std::shared_ptr<int>{};
0199     }
0200 
0201     void globalEndRun(edm::Run const&, edm::EventSetup const&) const override { ++m_count; }
0202   };
0203 
0204   class LumiProd : public edm::limited::EDFilter<edm::LuminosityBlockCache<int>> {
0205   public:
0206     LumiProd() : edm::limited::EDFilterBase(s_pset), edm::limited::EDFilter<edm::LuminosityBlockCache<int>>(s_pset) {}
0207     mutable unsigned int m_count = 0;
0208     bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {
0209       ++m_count;
0210       return true;
0211     }
0212 
0213     std::shared_ptr<int> globalBeginLuminosityBlock(edm::LuminosityBlock const&,
0214                                                     edm::EventSetup const&) const override {
0215       ++m_count;
0216       return std::shared_ptr<int>{};
0217     }
0218 
0219     void globalEndLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) const override { ++m_count; }
0220   };
0221 
0222   class RunSummaryProd : public edm::limited::EDFilter<edm::RunSummaryCache<int>> {
0223   public:
0224     RunSummaryProd() : edm::limited::EDFilterBase(s_pset), edm::limited::EDFilter<edm::RunSummaryCache<int>>(s_pset) {}
0225     mutable unsigned int m_count = 0;
0226     bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {
0227       ++m_count;
0228       return true;
0229     }
0230 
0231     std::shared_ptr<int> globalBeginRunSummary(edm::Run const&, edm::EventSetup const&) const override {
0232       ++m_count;
0233       return std::shared_ptr<int>{};
0234     }
0235 
0236     void streamEndRunSummary(edm::StreamID, edm::Run const&, edm::EventSetup const&, int*) const override { ++m_count; }
0237 
0238     void globalEndRunSummary(edm::Run const&, edm::EventSetup const&, int*) const override { ++m_count; }
0239   };
0240 
0241   class LumiSummaryProd : public edm::limited::EDFilter<edm::LuminosityBlockSummaryCache<int>> {
0242   public:
0243     LumiSummaryProd()
0244         : edm::limited::EDFilterBase(s_pset), edm::limited::EDFilter<edm::LuminosityBlockSummaryCache<int>>(s_pset) {}
0245     mutable unsigned int m_count = 0;
0246     bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {
0247       ++m_count;
0248       return true;
0249     }
0250 
0251     std::shared_ptr<int> globalBeginLuminosityBlockSummary(edm::LuminosityBlock const&,
0252                                                            edm::EventSetup const&) const override {
0253       ++m_count;
0254       return std::shared_ptr<int>{};
0255     }
0256 
0257     void streamEndLuminosityBlockSummary(edm::StreamID,
0258                                          edm::LuminosityBlock const&,
0259                                          edm::EventSetup const&,
0260                                          int*) const override {
0261       ++m_count;
0262     }
0263 
0264     void globalEndLuminosityBlockSummary(edm::LuminosityBlock const&, edm::EventSetup const&, int*) const override {
0265       ++m_count;
0266     }
0267   };
0268 
0269   class BeginRunProd : public edm::limited::EDFilter<edm::BeginRunProducer> {
0270   public:
0271     BeginRunProd() : edm::limited::EDFilterBase(s_pset), edm::limited::EDFilter<edm::BeginRunProducer>(s_pset) {}
0272     mutable unsigned int m_count = 0;
0273     bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {
0274       ++m_count;
0275       return true;
0276     }
0277 
0278     void globalBeginRunProduce(edm::Run&, edm::EventSetup const&) const override { ++m_count; }
0279   };
0280 
0281   class BeginLumiProd : public edm::limited::EDFilter<edm::BeginLuminosityBlockProducer> {
0282   public:
0283     BeginLumiProd()
0284         : edm::limited::EDFilterBase(s_pset), edm::limited::EDFilter<edm::BeginLuminosityBlockProducer>(s_pset) {}
0285     mutable unsigned int m_count = 0;
0286     bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {
0287       ++m_count;
0288       return true;
0289     }
0290 
0291     void globalBeginLuminosityBlockProduce(edm::LuminosityBlock&, edm::EventSetup const&) const override { ++m_count; }
0292   };
0293 
0294   class EndRunProd : public edm::limited::EDFilter<edm::EndRunProducer> {
0295   public:
0296     EndRunProd() : edm::limited::EDFilterBase(s_pset), edm::limited::EDFilter<edm::EndRunProducer>(s_pset) {}
0297     mutable unsigned int m_count = 0;
0298     bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {
0299       ++m_count;
0300       return true;
0301     }
0302 
0303     void globalEndRunProduce(edm::Run&, edm::EventSetup const&) const override { ++m_count; }
0304   };
0305 
0306   class EndLumiProd : public edm::limited::EDFilter<edm::EndLuminosityBlockProducer> {
0307   public:
0308     EndLumiProd()
0309         : edm::limited::EDFilterBase(s_pset), edm::limited::EDFilter<edm::EndLuminosityBlockProducer>(s_pset) {}
0310     mutable unsigned int m_count = 0;
0311     bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {
0312       ++m_count;
0313       return true;
0314     }
0315 
0316     void globalEndLuminosityBlockProduce(edm::LuminosityBlock&, edm::EventSetup const&) const override { ++m_count; }
0317   };
0318 
0319   class EndRunSummaryProd : public edm::limited::EDFilter<edm::EndRunProducer, edm::RunSummaryCache<int>> {
0320   public:
0321     EndRunSummaryProd()
0322         : edm::limited::EDFilterBase(s_pset),
0323           edm::limited::EDFilter<edm::EndRunProducer, edm::RunSummaryCache<int>>(s_pset) {}
0324     mutable unsigned int m_count = 0;
0325     mutable bool m_globalEndRunSummaryCalled = false;
0326     bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {
0327       ++m_count;
0328       return true;
0329     }
0330 
0331     std::shared_ptr<int> globalBeginRunSummary(edm::Run const&, edm::EventSetup const&) const override {
0332       ++m_count;
0333       return std::shared_ptr<int>{};
0334     }
0335 
0336     void streamEndRunSummary(edm::StreamID, edm::Run const&, edm::EventSetup const&, int*) const override { ++m_count; }
0337 
0338     void globalEndRunSummary(edm::Run const&, edm::EventSetup const&, int*) const override {
0339       ++m_count;
0340       CPPUNIT_ASSERT(m_globalEndRunSummaryCalled == false);
0341       m_globalEndRunSummaryCalled = true;
0342     }
0343 
0344     void globalEndRunProduce(edm::Run&, edm::EventSetup const&, int const*) const override {
0345       ++m_count;
0346       CPPUNIT_ASSERT(m_globalEndRunSummaryCalled == true);
0347       m_globalEndRunSummaryCalled = false;
0348     }
0349   };
0350 
0351   class EndLumiSummaryProd
0352       : public edm::limited::EDFilter<edm::EndLuminosityBlockProducer, edm::LuminosityBlockSummaryCache<int>> {
0353   public:
0354     EndLumiSummaryProd()
0355         : edm::limited::EDFilterBase(s_pset),
0356           edm::limited::EDFilter<edm::EndLuminosityBlockProducer, edm::LuminosityBlockSummaryCache<int>>(s_pset) {}
0357     mutable unsigned int m_count = 0;
0358     mutable bool m_globalEndLuminosityBlockSummaryCalled = false;
0359     bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {
0360       ++m_count;
0361       return true;
0362     }
0363 
0364     std::shared_ptr<int> globalBeginLuminosityBlockSummary(edm::LuminosityBlock const&,
0365                                                            edm::EventSetup const&) const override {
0366       ++m_count;
0367       return std::shared_ptr<int>{};
0368     }
0369 
0370     void streamEndLuminosityBlockSummary(edm::StreamID,
0371                                          edm::LuminosityBlock const&,
0372                                          edm::EventSetup const&,
0373                                          int*) const override {
0374       ++m_count;
0375     }
0376 
0377     void globalEndLuminosityBlockSummary(edm::LuminosityBlock const&, edm::EventSetup const&, int*) const override {
0378       ++m_count;
0379       CPPUNIT_ASSERT(m_globalEndLuminosityBlockSummaryCalled == false);
0380       m_globalEndLuminosityBlockSummaryCalled = true;
0381     }
0382 
0383     void globalEndLuminosityBlockProduce(edm::LuminosityBlock&, edm::EventSetup const&, int const*) const override {
0384       ++m_count;
0385       CPPUNIT_ASSERT(m_globalEndLuminosityBlockSummaryCalled == true);
0386       m_globalEndLuminosityBlockSummaryCalled = false;
0387     }
0388   };
0389 
0390   class TransformProd : public edm::limited::EDFilter<edm::Transformer> {
0391   public:
0392     TransformProd(edm::ParameterSet const&)
0393         : edm::limited::EDFilterBase(s_pset), edm::limited::EDFilter<edm::Transformer>(s_pset) {
0394       token_ = produces<float>();
0395       registerTransform(token_, [](edm::StreamID, float iV) { return int(iV); });
0396     }
0397 
0398     bool filter(edm::StreamID, edm::Event& iEvent, edm::EventSetup const&) const {
0399       //iEvent.emplace(token_, 3.625);
0400       return true;
0401     }
0402 
0403   private:
0404     edm::EDPutTokenT<float> token_;
0405   };
0406 };
0407 
0408 ///registration of the test so that the runner can find it
0409 CPPUNIT_TEST_SUITE_REGISTRATION(testLimitedFilter);
0410 
0411 testLimitedFilter::testLimitedFilter()
0412     : m_prodReg(new edm::ProductRegistry{}),
0413       m_idHelper(new edm::BranchIDListHelper{}),
0414       m_associationsHelper(new edm::ThinnedAssociationsHelper{}),
0415       m_ep() {
0416   //Setup the principals
0417   m_prodReg->setFrozen();
0418   m_idHelper->updateFromRegistry(*m_prodReg);
0419   edm::EventID eventID = edm::EventID::firstValidEvent();
0420 
0421   std::string uuid = edm::createGlobalIdentifier();
0422   edm::Timestamp now(1234567UL);
0423   m_rp.reset(
0424       new edm::RunPrincipal(m_prodReg, edm::productResolversFactory::makePrimary, m_procConfig, &historyAppender_, 0));
0425   m_rp->setAux(edm::RunAuxiliary(eventID.run(), now, now));
0426   edm::LuminosityBlockAuxiliary lumiAux(m_rp->run(), 1, now, now);
0427   m_lbp.reset(new edm::LuminosityBlockPrincipal(
0428       m_prodReg, edm::productResolversFactory::makePrimary, m_procConfig, &historyAppender_, 0));
0429   m_lbp->setAux(lumiAux);
0430   m_lbp->setRunPrincipal(m_rp);
0431   edm::EventAuxiliary eventAux(eventID, uuid, now, true);
0432 
0433   m_ep.reset(new edm::EventPrincipal(
0434       m_prodReg, edm::productResolversFactory::makePrimary, m_idHelper, m_associationsHelper, m_procConfig, nullptr));
0435   m_ep->fillEventPrincipal(eventAux, nullptr);
0436   m_ep->setLuminosityBlockPrincipal(m_lbp.get());
0437   m_actReg.reset(new edm::ActivityRegistry);
0438 
0439   //For each transition, bind a lambda which will call the proper method of the Worker
0440   m_transToFunc[Trans::kBeginStream] = [](edm::Worker* iBase) {
0441     edm::StreamContext streamContext(s_streamID0, nullptr);
0442     iBase->beginStream(s_streamID0, streamContext);
0443   };
0444 
0445   m_transToFunc[Trans::kGlobalBeginRun] = [this](edm::Worker* iBase) {
0446     typedef edm::OccurrenceTraits<edm::RunPrincipal, edm::BranchActionGlobalBegin> Traits;
0447     edm::GlobalContext gc(edm::GlobalContext::Transition::kBeginRun, nullptr);
0448     edm::ParentContext nullParentContext(&gc);
0449     iBase->setActivityRegistry(m_actReg);
0450     edm::RunTransitionInfo info(*m_rp, *m_es);
0451     doWork<Traits>(iBase, info, nullParentContext);
0452   };
0453   m_transToFunc[Trans::kStreamBeginRun] = [this](edm::Worker* iBase) {
0454     typedef edm::OccurrenceTraits<edm::RunPrincipal, edm::BranchActionStreamBegin> Traits;
0455     edm::StreamContext streamContext(s_streamID0, nullptr);
0456     edm::ParentContext nullParentContext(&streamContext);
0457     iBase->setActivityRegistry(m_actReg);
0458     edm::RunTransitionInfo info(*m_rp, *m_es);
0459     doWork<Traits>(iBase, info, nullParentContext);
0460   };
0461 
0462   m_transToFunc[Trans::kGlobalBeginLuminosityBlock] = [this](edm::Worker* iBase) {
0463     typedef edm::OccurrenceTraits<edm::LuminosityBlockPrincipal, edm::BranchActionGlobalBegin> Traits;
0464     edm::GlobalContext gc(edm::GlobalContext::Transition::kBeginLuminosityBlock, nullptr);
0465     edm::ParentContext nullParentContext(&gc);
0466     iBase->setActivityRegistry(m_actReg);
0467     edm::LumiTransitionInfo info(*m_lbp, *m_es);
0468     doWork<Traits>(iBase, info, nullParentContext);
0469   };
0470   m_transToFunc[Trans::kStreamBeginLuminosityBlock] = [this](edm::Worker* iBase) {
0471     typedef edm::OccurrenceTraits<edm::LuminosityBlockPrincipal, edm::BranchActionStreamBegin> Traits;
0472     edm::StreamContext streamContext(s_streamID0, nullptr);
0473     edm::ParentContext nullParentContext(&streamContext);
0474     iBase->setActivityRegistry(m_actReg);
0475     edm::LumiTransitionInfo info(*m_lbp, *m_es);
0476     doWork<Traits>(iBase, info, nullParentContext);
0477   };
0478 
0479   m_transToFunc[Trans::kEvent] = [this](edm::Worker* iBase) {
0480     typedef edm::OccurrenceTraits<edm::EventPrincipal, edm::BranchActionStreamBegin> Traits;
0481     edm::StreamContext streamContext(s_streamID0, nullptr);
0482     edm::ParentContext nullParentContext(&streamContext);
0483     iBase->setActivityRegistry(m_actReg);
0484     edm::EventTransitionInfo info(*m_ep, *m_es);
0485     doWork<Traits>(iBase, info, nullParentContext);
0486   };
0487 
0488   m_transToFunc[Trans::kStreamEndLuminosityBlock] = [this](edm::Worker* iBase) {
0489     typedef edm::OccurrenceTraits<edm::LuminosityBlockPrincipal, edm::BranchActionStreamEnd> Traits;
0490     edm::StreamContext streamContext(s_streamID0, nullptr);
0491     edm::ParentContext nullParentContext(&streamContext);
0492     iBase->setActivityRegistry(m_actReg);
0493     edm::LumiTransitionInfo info(*m_lbp, *m_es);
0494     doWork<Traits>(iBase, info, nullParentContext);
0495   };
0496   m_transToFunc[Trans::kGlobalEndLuminosityBlock] = [this](edm::Worker* iBase) {
0497     typedef edm::OccurrenceTraits<edm::LuminosityBlockPrincipal, edm::BranchActionGlobalEnd> Traits;
0498     edm::GlobalContext gc(edm::GlobalContext::Transition::kEndLuminosityBlock, nullptr);
0499     edm::ParentContext nullParentContext(&gc);
0500     iBase->setActivityRegistry(m_actReg);
0501     edm::LumiTransitionInfo info(*m_lbp, *m_es);
0502     doWork<Traits>(iBase, info, nullParentContext);
0503   };
0504 
0505   m_transToFunc[Trans::kStreamEndRun] = [this](edm::Worker* iBase) {
0506     typedef edm::OccurrenceTraits<edm::RunPrincipal, edm::BranchActionStreamEnd> Traits;
0507     edm::StreamContext streamContext(s_streamID0, nullptr);
0508     edm::ParentContext nullParentContext(&streamContext);
0509     iBase->setActivityRegistry(m_actReg);
0510     edm::RunTransitionInfo info(*m_rp, *m_es);
0511     doWork<Traits>(iBase, info, nullParentContext);
0512   };
0513   m_transToFunc[Trans::kGlobalEndRun] = [this](edm::Worker* iBase) {
0514     typedef edm::OccurrenceTraits<edm::RunPrincipal, edm::BranchActionGlobalEnd> Traits;
0515     edm::GlobalContext gc(edm::GlobalContext::Transition::kEndRun, nullptr);
0516     edm::ParentContext nullParentContext(&gc);
0517     iBase->setActivityRegistry(m_actReg);
0518     edm::RunTransitionInfo info(*m_rp, *m_es);
0519     doWork<Traits>(iBase, info, nullParentContext);
0520   };
0521 
0522   m_transToFunc[Trans::kEndStream] = [](edm::Worker* iBase) {
0523     edm::StreamContext streamContext(s_streamID0, nullptr);
0524     iBase->endStream(s_streamID0, streamContext);
0525   };
0526 }
0527 
0528 namespace {
0529   template <typename T>
0530   void testTransition(std::shared_ptr<T> iMod,
0531                       edm::Worker* iWorker,
0532                       testLimitedFilter::Trans iTrans,
0533                       testLimitedFilter::Expectations const& iExpect,
0534                       std::function<void(edm::Worker*)> iFunc) {
0535     assert(0 == iMod->m_count);
0536     iFunc(iWorker);
0537     auto count = std::count(iExpect.begin(), iExpect.end(), iTrans);
0538     if (count != iMod->m_count) {
0539       std::cout << "For trans " << static_cast<std::underlying_type<testLimitedFilter::Trans>::type>(iTrans)
0540                 << " expected " << count << " and got " << iMod->m_count << std::endl;
0541     }
0542     CPPUNIT_ASSERT(iMod->m_count == count);
0543     iMod->m_count = 0;
0544     iWorker->reset();
0545   }
0546 }  // namespace
0547 
0548 template <typename T>
0549 void testLimitedFilter::testTransitions(std::shared_ptr<T> iMod, Expectations const& iExpect) {
0550   oneapi::tbb::global_control control(oneapi::tbb::global_control::max_allowed_parallelism, 1);
0551 
0552   edm::maker::ModuleHolderT<edm::limited::EDFilterBase> h(iMod, nullptr);
0553   h.preallocate(edm::PreallocationConfiguration{});
0554   edm::WorkerT<edm::limited::EDFilterBase> wOther{iMod, m_desc, nullptr};
0555   edm::WorkerT<edm::limited::EDFilterBase> wGlobalLumi{iMod, m_desc, nullptr};
0556   edm::WorkerT<edm::limited::EDFilterBase> wStreamLumi{iMod, m_desc, nullptr};
0557   edm::WorkerT<edm::limited::EDFilterBase> wGlobalRun{iMod, m_desc, nullptr};
0558   edm::WorkerT<edm::limited::EDFilterBase> wStreamRun{iMod, m_desc, nullptr};
0559   for (auto& keyVal : m_transToFunc) {
0560     edm::Worker* worker = &wOther;
0561     if (keyVal.first == Trans::kStreamBeginLuminosityBlock || keyVal.first == Trans::kStreamEndLuminosityBlock) {
0562       worker = &wStreamLumi;
0563     } else if (keyVal.first == Trans::kGlobalBeginLuminosityBlock || keyVal.first == Trans::kGlobalEndLuminosityBlock) {
0564       worker = &wGlobalLumi;
0565     } else if (keyVal.first == Trans::kStreamBeginRun || keyVal.first == Trans::kStreamEndRun) {
0566       worker = &wStreamRun;
0567     } else if (keyVal.first == Trans::kGlobalBeginRun || keyVal.first == Trans::kGlobalEndRun) {
0568       worker = &wGlobalRun;
0569     }
0570     testTransition(iMod, worker, keyVal.first, iExpect, keyVal.second);
0571   }
0572 }
0573 
0574 void testLimitedFilter::basicTest() {
0575   auto testProd = std::make_shared<BasicProd>();
0576 
0577   CPPUNIT_ASSERT(0 == testProd->m_count);
0578   testTransitions(testProd, {Trans::kEvent});
0579 }
0580 
0581 void testLimitedFilter::streamTest() {
0582   auto testProd = std::make_shared<StreamProd>();
0583 
0584   CPPUNIT_ASSERT(0 == testProd->m_count);
0585   testTransitions(testProd,
0586                   {Trans::kBeginStream,
0587                    Trans::kStreamBeginRun,
0588                    Trans::kStreamBeginLuminosityBlock,
0589                    Trans::kEvent,
0590                    Trans::kStreamEndLuminosityBlock,
0591                    Trans::kStreamEndRun,
0592                    Trans::kEndStream});
0593 }
0594 
0595 void testLimitedFilter::runTest() {
0596   auto testProd = std::make_shared<RunProd>();
0597 
0598   CPPUNIT_ASSERT(0 == testProd->m_count);
0599   testTransitions(testProd, {Trans::kGlobalBeginRun, Trans::kEvent, Trans::kGlobalEndRun});
0600 }
0601 
0602 void testLimitedFilter::runSummaryTest() {
0603   auto testProd = std::make_shared<RunSummaryProd>();
0604 
0605   CPPUNIT_ASSERT(0 == testProd->m_count);
0606   testTransitions(testProd, {Trans::kGlobalBeginRun, Trans::kEvent, Trans::kStreamEndRun, Trans::kGlobalEndRun});
0607 }
0608 
0609 void testLimitedFilter::lumiTest() {
0610   auto testProd = std::make_shared<LumiProd>();
0611 
0612   CPPUNIT_ASSERT(0 == testProd->m_count);
0613   testTransitions(testProd, {Trans::kGlobalBeginLuminosityBlock, Trans::kEvent, Trans::kGlobalEndLuminosityBlock});
0614 }
0615 
0616 void testLimitedFilter::lumiSummaryTest() {
0617   auto testProd = std::make_shared<LumiSummaryProd>();
0618 
0619   CPPUNIT_ASSERT(0 == testProd->m_count);
0620   testTransitions(testProd,
0621                   {Trans::kGlobalBeginLuminosityBlock,
0622                    Trans::kEvent,
0623                    Trans::kStreamEndLuminosityBlock,
0624                    Trans::kGlobalEndLuminosityBlock});
0625 }
0626 
0627 void testLimitedFilter::beginRunProdTest() {
0628   auto testProd = std::make_shared<BeginRunProd>();
0629 
0630   CPPUNIT_ASSERT(0 == testProd->m_count);
0631   testTransitions(testProd, {Trans::kGlobalBeginRun, Trans::kEvent});
0632 }
0633 
0634 void testLimitedFilter::beginLumiProdTest() {
0635   auto testProd = std::make_shared<BeginLumiProd>();
0636 
0637   CPPUNIT_ASSERT(0 == testProd->m_count);
0638   testTransitions(testProd, {Trans::kGlobalBeginLuminosityBlock, Trans::kEvent});
0639 }
0640 
0641 void testLimitedFilter::endRunProdTest() {
0642   auto testProd = std::make_shared<EndRunProd>();
0643 
0644   CPPUNIT_ASSERT(0 == testProd->m_count);
0645   testTransitions(testProd, {Trans::kGlobalEndRun, Trans::kEvent});
0646 }
0647 
0648 void testLimitedFilter::endLumiProdTest() {
0649   auto testProd = std::make_shared<EndLumiProd>();
0650 
0651   CPPUNIT_ASSERT(0 == testProd->m_count);
0652   testTransitions(testProd, {Trans::kGlobalEndLuminosityBlock, Trans::kEvent});
0653 }
0654 
0655 void testLimitedFilter::endRunSummaryProdTest() {
0656   auto testProd = std::make_shared<EndRunSummaryProd>();
0657 
0658   CPPUNIT_ASSERT(0 == testProd->m_count);
0659   testTransitions(
0660       testProd,
0661       {Trans::kGlobalEndRun, Trans::kEvent, Trans::kGlobalBeginRun, Trans::kStreamEndRun, Trans::kGlobalEndRun});
0662 }
0663 
0664 void testLimitedFilter::endLumiSummaryProdTest() {
0665   auto testProd = std::make_shared<EndLumiSummaryProd>();
0666 
0667   CPPUNIT_ASSERT(0 == testProd->m_count);
0668   testTransitions(testProd,
0669                   {Trans::kGlobalEndLuminosityBlock,
0670                    Trans::kEvent,
0671                    Trans::kGlobalBeginLuminosityBlock,
0672                    Trans::kStreamEndLuminosityBlock,
0673                    Trans::kGlobalEndLuminosityBlock});
0674 }
[ 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!